diff --git a/packages/eslint-plugin/docs/rules/no-confusing-void-expression.mdx b/packages/eslint-plugin/docs/rules/no-confusing-void-expression.mdx
index 043b07521c6b..b791705dd348 100644
--- a/packages/eslint-plugin/docs/rules/no-confusing-void-expression.mdx
+++ b/packages/eslint-plugin/docs/rules/no-confusing-void-expression.mdx
@@ -115,6 +115,24 @@ function doSomething() {
 console.log(void alert('Hello, world!'));
 ```
 
+### `ignoreVoidInVoid`
+
+Allow using `void` type expressions in return value of a function that specified as `void`
+
+Examples of additional **correct** code with this option enabled:
+
+```ts option='{ "ignoreVoidInVoid": true }' showPlaygroundButton
+function test1(value: string): void {
+  return window.postMessage(value);
+}
+
+const test2 = (value: string): void => window.postMessage(value);
+
+const test3 = (value: string): void => {
+  return window.postMessage(value);
+};
+```
+
 ## When Not To Use It
 
 The return type of a function can be inspected by going to its definition or hovering over it in an IDE.
diff --git a/packages/eslint-plugin/src/rules/no-confusing-void-expression.ts b/packages/eslint-plugin/src/rules/no-confusing-void-expression.ts
index 38df4fb0dc44..b28fc4011221 100644
--- a/packages/eslint-plugin/src/rules/no-confusing-void-expression.ts
+++ b/packages/eslint-plugin/src/rules/no-confusing-void-expression.ts
@@ -14,11 +14,16 @@ import {
   nullThrows,
   NullThrowsReasons,
 } from '../util';
+import {
+  ancestorHasReturnType,
+  isValidFunctionExpressionReturnType,
+} from '../util/explicitReturnTypeUtils';
 
 export type Options = [
   {
     ignoreArrowShorthand?: boolean;
     ignoreVoidOperator?: boolean;
+    ignoreVoidInVoid?: boolean;
   },
 ];
 
@@ -32,6 +37,26 @@ export type MessageId =
   | 'invalidVoidExprWrapVoid'
   | 'voidExprWrapVoid';
 
+function findFunction(
+  node: TSESTree.Node | undefined,
+):
+  | TSESTree.FunctionExpression
+  | TSESTree.ArrowFunctionExpression
+  | TSESTree.FunctionDeclaration
+  | null {
+  if (!node) {
+    return null;
+  }
+  if (
+    node.type === AST_NODE_TYPES.FunctionExpression ||
+    node.type === AST_NODE_TYPES.ArrowFunctionExpression ||
+    node.type === AST_NODE_TYPES.FunctionDeclaration
+  ) {
+    return node;
+  }
+  return findFunction(node.parent);
+}
+
 export default createRule<Options, MessageId>({
   name: 'no-confusing-void-expression',
   meta: {
@@ -72,6 +97,7 @@ export default createRule<Options, MessageId>({
         properties: {
           ignoreArrowShorthand: { type: 'boolean' },
           ignoreVoidOperator: { type: 'boolean' },
+          ignoreVoidInVoid: { type: 'boolean' },
         },
         additionalProperties: false,
       },
@@ -80,8 +106,13 @@ export default createRule<Options, MessageId>({
     fixable: 'code',
     hasSuggestions: true,
   },
-  defaultOptions: [{ ignoreArrowShorthand: false, ignoreVoidOperator: false }],
-
+  defaultOptions: [
+    {
+      ignoreArrowShorthand: false,
+      ignoreVoidOperator: false,
+      ignoreVoidInVoid: false,
+    },
+  ],
   create(context, [options]) {
     return {
       'AwaitExpression, CallExpression, TaggedTemplateExpression'(
@@ -98,6 +129,7 @@ export default createRule<Options, MessageId>({
         }
 
         const invalidAncestor = findInvalidAncestor(node);
+
         if (invalidAncestor == null) {
           // void expression is in valid position
           return;
@@ -112,6 +144,12 @@ export default createRule<Options, MessageId>({
         if (invalidAncestor.type === AST_NODE_TYPES.ArrowFunctionExpression) {
           // handle arrow function shorthand
 
+          if (options.ignoreVoidInVoid) {
+            if (hasValidReturnType(invalidAncestor)) {
+              return;
+            }
+          }
+
           if (options.ignoreVoidOperator) {
             // handle wrapping with `void`
             return context.report({
@@ -167,6 +205,14 @@ export default createRule<Options, MessageId>({
         if (invalidAncestor.type === AST_NODE_TYPES.ReturnStatement) {
           // handle return statement
 
+          if (options.ignoreVoidInVoid) {
+            const functionNode = findFunction(invalidAncestor);
+
+            if (hasValidReturnType(functionNode)) {
+              return;
+            }
+          }
+
           if (options.ignoreVoidOperator) {
             // handle wrapping with `void`
             return context.report({
@@ -376,5 +422,44 @@ export default createRule<Options, MessageId>({
       const type = getConstrainedTypeAtLocation(services, targetNode);
       return tsutils.isTypeFlagSet(type, ts.TypeFlags.VoidLike);
     }
+
+    function hasValidReturnType(
+      node:
+        | TSESTree.FunctionExpression
+        | TSESTree.ArrowFunctionExpression
+        | TSESTree.FunctionDeclaration
+        | null,
+    ): boolean {
+      const services = getParserServices(context);
+
+      if (node != null) {
+        const functionTSNode = services.esTreeNodeToTSNodeMap.get(node);
+        const functionType = services.getTypeAtLocation(node);
+
+        if (functionTSNode.type) {
+          const signatures = tsutils.getCallSignaturesOfType(functionType);
+
+          return !signatures.every(signature =>
+            tsutils.isTypeFlagSet(
+              signature.getReturnType(),
+              ts.TypeFlags.Any | ts.TypeFlags.Unknown,
+            ),
+          );
+        }
+
+        if (
+          ((node.type === AST_NODE_TYPES.FunctionExpression ||
+            node.type === AST_NODE_TYPES.ArrowFunctionExpression) &&
+            isValidFunctionExpressionReturnType(node, {
+              allowTypedFunctionExpressions: true,
+            })) ||
+          ancestorHasReturnType(node)
+        ) {
+          return true;
+        }
+      }
+
+      return false;
+    }
   },
 });
diff --git a/packages/eslint-plugin/tests/docs-eslint-output-snapshots/no-confusing-void-expression.shot b/packages/eslint-plugin/tests/docs-eslint-output-snapshots/no-confusing-void-expression.shot
index bf20e61945c3..d044ead177c9 100644
--- a/packages/eslint-plugin/tests/docs-eslint-output-snapshots/no-confusing-void-expression.shot
+++ b/packages/eslint-plugin/tests/docs-eslint-output-snapshots/no-confusing-void-expression.shot
@@ -80,3 +80,18 @@ function doSomething() {
 console.log(void alert('Hello, world!'));
 "
 `;
+
+exports[`Validating rule docs no-confusing-void-expression.mdx code examples ESLint output 5`] = `
+"Options: { "ignoreVoidInVoid": true }
+
+function test1(value: string): void {
+  return window.postMessage(value);
+}
+
+const test2 = (value: string): void => window.postMessage(value);
+
+const test3 = (value: string): void => {
+  return window.postMessage(value);
+};
+"
+`;
diff --git a/packages/eslint-plugin/tests/rules/no-confusing-void-expression.test.ts b/packages/eslint-plugin/tests/rules/no-confusing-void-expression.test.ts
index 921ee833894c..6948cd15b781 100644
--- a/packages/eslint-plugin/tests/rules/no-confusing-void-expression.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-confusing-void-expression.test.ts
@@ -119,6 +119,325 @@ function cool(input: string) {
 }
       `,
     },
+    {
+      options: [{ ignoreVoidInVoid: true }],
+      code: `
+function test(): void {
+  return console.log('foo');
+}
+      `,
+    },
+    {
+      options: [{ ignoreVoidInVoid: true }],
+      code: "const test = (): void => console.log('foo');",
+    },
+    {
+      options: [{ ignoreVoidInVoid: true }],
+      code: `
+const test = (): void => {
+  return console.log('foo');
+};
+      `,
+    },
+    {
+      options: [{ ignoreVoidInVoid: true }],
+      code: `
+function test(): void {
+  {
+    return console.log('foo');
+  }
+}
+      `,
+    },
+    {
+      options: [{ ignoreVoidInVoid: true }],
+      code: `
+const data = {
+  test(): void {
+    return console.log('foo');
+  },
+};
+      `,
+    },
+    {
+      options: [{ ignoreVoidInVoid: true }],
+      code: `
+class Foo {
+  test(): void {
+    return console.log('foo');
+  }
+}
+      `,
+    },
+    {
+      options: [{ ignoreVoidInVoid: true }],
+      code: `
+const test = function (): void {
+  return console.log('foo');
+};
+      `,
+    },
+    {
+      options: [{ ignoreVoidInVoid: true }],
+      code: `
+function test() {
+  function nestedTest(): void {
+    return console.log('foo');
+  }
+}
+      `,
+    },
+    {
+      options: [{ ignoreVoidInVoid: true }],
+      code: `
+type Foo = void;
+
+function test(): Foo {
+  return console.log();
+}
+      `,
+    },
+    {
+      options: [{ ignoreVoidInVoid: true }],
+      code: `
+function returnVoid(): void {}
+
+function test(): void {
+  return returnVoid();
+}
+      `,
+    },
+    {
+      options: [{ ignoreVoidInVoid: true }],
+      code: `
+type Foo = void;
+function returnVoid(): void {}
+
+function test(): Foo {
+  return returnVoid();
+}
+      `,
+    },
+    {
+      options: [{ ignoreVoidInVoid: true }],
+      code: `
+function test(): void & void {
+  return console.log('foo');
+}
+      `,
+    },
+    {
+      options: [{ ignoreVoidInVoid: true }],
+      code: `
+type Foo = void;
+declare function foo(): Foo;
+function test(): Foo {
+  return foo();
+}
+      `,
+    },
+    {
+      options: [{ ignoreVoidInVoid: true }],
+      code: `
+type Foo = void;
+const test = (): Foo => console.log('err');
+      `,
+    },
+    {
+      code: `
+type Foo = () => void;
+const arrowFn: Foo = () => console.log('foo');
+      `,
+      options: [{ ignoreVoidInVoid: true }],
+    },
+    {
+      code: `
+type Foo = () => void;
+const funcExpr: Foo = function () {
+  return console.log();
+};
+      `,
+      options: [{ ignoreVoidInVoid: true }],
+    },
+    {
+      code: `
+type Foo = () => void;
+const test: Foo = () => {
+  return console.log();
+};
+      `,
+      options: [{ ignoreVoidInVoid: true }],
+    },
+    {
+      code: `
+type Foo = () => void;
+const test = (() => console.log()) as Foo;
+      `,
+      options: [{ ignoreVoidInVoid: true }],
+    },
+    {
+      code: `
+type Foo = {
+  foo: () => void;
+};
+const test = {
+  foo: () => console.log(),
+} as Foo;
+      `,
+      options: [{ ignoreVoidInVoid: true }],
+    },
+    {
+      code: `
+type Foo = {
+  foo: () => void;
+};
+const test: Foo = {
+  foo: () => console.log(),
+};
+      `,
+      options: [{ ignoreVoidInVoid: true }],
+    },
+    {
+      code: `
+const test = {
+  foo: () => console.log(),
+} as {
+  foo: () => void;
+};
+      `,
+      options: [{ ignoreVoidInVoid: true }],
+    },
+    {
+      code: `
+const test: {
+  foo: () => void;
+} = {
+  foo: () => console.log(),
+};
+      `,
+      options: [{ ignoreVoidInVoid: true }],
+    },
+    {
+      code: `
+type Foo = {
+  foo: { bar: () => void };
+};
+const test = {
+  foo: { bar: () => console.log() },
+} as Foo;
+      `,
+      options: [{ ignoreVoidInVoid: true }],
+    },
+    {
+      code: `
+type Foo = {
+  foo: { bar: () => void };
+};
+const test: Foo = {
+  foo: { bar: () => console.log() },
+};
+      `,
+      options: [{ ignoreVoidInVoid: true }],
+    },
+    {
+      code: `
+type MethodType = () => void;
+
+class App {
+  private method: MethodType = () => console.log();
+}
+      `,
+      options: [{ ignoreVoidInVoid: true }],
+    },
+    {
+      code: `
+interface Foo {
+  foo: () => void;
+}
+function bar(): Foo {
+  return {
+    foo: () => console.log(),
+  };
+}
+      `,
+      options: [{ ignoreVoidInVoid: true }],
+    },
+    {
+      code: `
+type HigherOrderType = () => () => () => void;
+const x: HigherOrderType = () => () => () => console.log();
+      `,
+      options: [{ ignoreVoidInVoid: true }],
+    },
+    {
+      code: `
+declare function foo(arg: () => void): void;
+foo(() => console.log());
+      `,
+      options: [{ ignoreVoidInVoid: true }],
+    },
+    {
+      code: 'const foo = <button onClick={() => console.log()} />;',
+      options: [{ ignoreVoidInVoid: true }],
+      parserOptions: {
+        ecmaFeatures: {
+          jsx: true,
+        },
+      },
+    },
+    {
+      code: `
+type HigherOrderType = () => () => () => void;
+const x: HigherOrderType = () => () => () => {
+  return console.log();
+};
+      `,
+      options: [{ ignoreVoidInVoid: true }],
+    },
+    {
+      code: `
+type HigherOrderType = () => () => () => void;
+const x: HigherOrderType = () => () =>
+  function () {
+    return console.log();
+  };
+      `,
+      options: [{ ignoreVoidInVoid: true }],
+    },
+    {
+      code: `
+function test(): void;
+function test(arg: string): any;
+function test(arg?: string): any | void {
+  if (arg) {
+    return arg;
+  }
+
+  return console.log();
+}
+      `,
+      options: [{ ignoreVoidInVoid: true }],
+    },
+    {
+      code: `
+function test(arg: string): any;
+function test(): void;
+function test(arg?: string): any | void {
+  if (arg) {
+    return arg;
+  }
+
+  return console.log();
+}
+      `,
+      options: [{ ignoreVoidInVoid: true }],
+    },
+    {
+      code: `
+const test: () => any = (): void => console.log();
+      `,
+      options: [{ ignoreVoidInVoid: true }],
+    },
   ],
 
   invalid: [
@@ -493,5 +812,369 @@ function notcool(input: string) {
         },
       ],
     },
+    {
+      options: [{ ignoreVoidInVoid: true }],
+      code: `
+function test() {
+  return console.log('foo');
+}
+      `,
+      errors: [
+        {
+          line: 3,
+          column: 10,
+          messageId: 'invalidVoidExprReturnLast',
+        },
+      ],
+      output: `
+function test() {
+  console.log('foo');
+}
+      `,
+    },
+    {
+      options: [{ ignoreVoidInVoid: true }],
+      code: "const test = () => console.log('foo');",
+      errors: [
+        {
+          line: 1,
+          column: 20,
+          messageId: 'invalidVoidExprArrow',
+        },
+      ],
+      output: "const test = () => { console.log('foo'); };",
+    },
+    {
+      options: [{ ignoreVoidInVoid: true }],
+      code: `
+const test = () => {
+  return console.log('foo');
+};
+      `,
+      errors: [
+        {
+          line: 3,
+          column: 10,
+          messageId: 'invalidVoidExprReturnLast',
+        },
+      ],
+      output: `
+const test = () => {
+  console.log('foo');
+};
+      `,
+    },
+    {
+      options: [{ ignoreVoidInVoid: true }],
+      code: `
+function foo(): void {
+  const bar = () => {
+    return console.log();
+  };
+}
+      `,
+      errors: [
+        {
+          line: 4,
+          column: 12,
+          messageId: 'invalidVoidExprReturnLast',
+        },
+      ],
+      output: `
+function foo(): void {
+  const bar = () => {
+    console.log();
+  };
+}
+      `,
+    },
+    {
+      options: [{ ignoreVoidInVoid: true }],
+      code: `
+return console.log('foo');
+      `,
+      errors: [
+        {
+          line: 2,
+          column: 8,
+          messageId: 'invalidVoidExprReturn',
+        },
+      ],
+      output: `
+{ console.log('foo'); return; }
+      `,
+    },
+    {
+      options: [{ ignoreVoidInVoid: true }],
+      code: `
+type Foo = () => void;
+const test1: Foo = function () {
+  function testtt() {
+    return console.log();
+  }
+};
+      `,
+      errors: [
+        {
+          line: 5,
+          column: 12,
+          messageId: 'invalidVoidExprReturnLast',
+        },
+      ],
+      output: `
+type Foo = () => void;
+const test1: Foo = function () {
+  function testtt() {
+    console.log();
+  }
+};
+      `,
+    },
+    {
+      options: [{ ignoreVoidInVoid: true }],
+      code: `
+type Foo = () => void;
+const test2 = function () {
+  function testtt() {
+    return console.log();
+  }
+};
+      `,
+      errors: [
+        {
+          line: 5,
+          column: 12,
+          messageId: 'invalidVoidExprReturnLast',
+        },
+      ],
+      output: `
+type Foo = () => void;
+const test2 = function () {
+  function testtt() {
+    console.log();
+  }
+};
+      `,
+    },
+    {
+      options: [{ ignoreVoidInVoid: true }],
+      code: `
+        (): any => console.log('foo');
+      `,
+      errors: [
+        {
+          line: 2,
+          column: 20,
+          messageId: 'invalidVoidExprArrow',
+        },
+      ],
+      output: `
+        (): any => { console.log('foo'); };
+      `,
+    },
+    {
+      options: [{ ignoreVoidInVoid: true }],
+      code: `
+        (): unknown => console.log('foo');
+      `,
+      errors: [
+        {
+          line: 2,
+          column: 24,
+          messageId: 'invalidVoidExprArrow',
+        },
+      ],
+      output: `
+        (): unknown => { console.log('foo'); };
+      `,
+    },
+    {
+      options: [{ ignoreVoidInVoid: true }],
+      code: `
+function test(): any {
+  return console.log();
+}
+      `,
+      errors: [
+        {
+          line: 3,
+          column: 10,
+          messageId: 'invalidVoidExprReturnLast',
+        },
+      ],
+      output: `
+function test(): any {
+  console.log();
+}
+      `,
+    },
+    {
+      options: [{ ignoreVoidInVoid: true }],
+      code: `
+function test(): unknown {
+  return console.log();
+}
+      `,
+      errors: [
+        {
+          line: 3,
+          column: 10,
+          messageId: 'invalidVoidExprReturnLast',
+        },
+      ],
+      output: `
+function test(): unknown {
+  console.log();
+}
+      `,
+    },
+    {
+      code: `
+function foo(): void {
+  () => () => console.log();
+}
+      `,
+      options: [{ ignoreVoidInVoid: true }],
+      errors: [
+        {
+          line: 3,
+          column: 15,
+          messageId: 'invalidVoidExprArrow',
+        },
+      ],
+      output: `
+function foo(): void {
+  () => () => { console.log(); };
+}
+      `,
+    },
+    {
+      code: `
+function foo(): any {
+  () => () => console.log();
+}
+      `,
+      options: [{ ignoreVoidInVoid: true }],
+      errors: [
+        {
+          line: 3,
+          column: 15,
+          messageId: 'invalidVoidExprArrow',
+        },
+      ],
+      output: `
+function foo(): any {
+  () => () => { console.log(); };
+}
+      `,
+    },
+    {
+      code: `
+type Foo = any;
+(): Foo => console.log();
+      `,
+      options: [{ ignoreVoidInVoid: true }],
+      errors: [
+        {
+          line: 3,
+          column: 12,
+          messageId: 'invalidVoidExprArrow',
+        },
+      ],
+      output: `
+type Foo = any;
+(): Foo => { console.log(); };
+      `,
+    },
+    {
+      code: `
+type Foo = unknown;
+(): Foo => console.log();
+      `,
+      options: [{ ignoreVoidInVoid: true }],
+      errors: [
+        {
+          line: 3,
+          column: 12,
+          messageId: 'invalidVoidExprArrow',
+        },
+      ],
+      output: `
+type Foo = unknown;
+(): Foo => { console.log(); };
+      `,
+    },
+    {
+      code: `
+      type HigherOrderType = () => any;
+      (): HigherOrderType => () => console.log();
+      `,
+      options: [{ ignoreVoidInVoid: true }],
+      errors: [
+        {
+          line: 3,
+          column: 36,
+          messageId: 'invalidVoidExprArrow',
+        },
+      ],
+      output: `
+      type HigherOrderType = () => any;
+      (): HigherOrderType => () => { console.log(); };
+      `,
+    },
+    {
+      code: `
+      type HigherOrderType = () => unknown;
+      (): HigherOrderType => () => console.log();
+      `,
+      options: [{ ignoreVoidInVoid: true }],
+      errors: [
+        {
+          line: 3,
+          column: 36,
+          messageId: 'invalidVoidExprArrow',
+        },
+      ],
+      output: `
+      type HigherOrderType = () => unknown;
+      (): HigherOrderType => () => { console.log(); };
+      `,
+    },
+    {
+      code: `
+      type HigherOrderType = () => any;
+      const x: HigherOrderType = () => console.log();
+      `,
+      options: [{ ignoreVoidInVoid: true }],
+      errors: [
+        {
+          line: 3,
+          column: 40,
+          messageId: 'invalidVoidExprArrow',
+        },
+      ],
+      output: `
+      type HigherOrderType = () => any;
+      const x: HigherOrderType = () => { console.log(); };
+      `,
+    },
+    {
+      code: `
+      type HigherOrderType = () => unknown;
+      const x: HigherOrderType = () => console.log();
+      `,
+      options: [{ ignoreVoidInVoid: true }],
+      errors: [
+        {
+          line: 3,
+          column: 40,
+          messageId: 'invalidVoidExprArrow',
+        },
+      ],
+      output: `
+      type HigherOrderType = () => unknown;
+      const x: HigherOrderType = () => { console.log(); };
+      `,
+    },
   ],
 });
diff --git a/packages/eslint-plugin/tests/schema-snapshots/no-confusing-void-expression.shot b/packages/eslint-plugin/tests/schema-snapshots/no-confusing-void-expression.shot
index b7481d1000ce..9342d33fb981 100644
--- a/packages/eslint-plugin/tests/schema-snapshots/no-confusing-void-expression.shot
+++ b/packages/eslint-plugin/tests/schema-snapshots/no-confusing-void-expression.shot
@@ -11,6 +11,9 @@ exports[`Rule schemas should be convertible to TS types for documentation purpos
       "ignoreArrowShorthand": {
         "type": "boolean"
       },
+      "ignoreVoidInVoid": {
+        "type": "boolean"
+      },
       "ignoreVoidOperator": {
         "type": "boolean"
       }
@@ -25,6 +28,7 @@ exports[`Rule schemas should be convertible to TS types for documentation purpos
 type Options = [
   {
     ignoreArrowShorthand?: boolean;
+    ignoreVoidInVoid?: boolean;
     ignoreVoidOperator?: boolean;
   },
 ];