diff --git a/test/rules/sort-classes.test.ts b/test/rules/sort-classes.test.ts
index 387900b31..dfecb75eb 100644
--- a/test/rules/sort-classes.test.ts
+++ b/test/rules/sort-classes.test.ts
@@ -4513,6 +4513,61 @@ describe(ruleName, () => {
           valid: [],
         },
       )
+
+      ruleTester.run(
+        `${ruleName}(${type}): handles newlines and comment after fixes`,
+        rule,
+        {
+          invalid: [
+            {
+              output: [
+                dedent`
+                  class Class {
+                    a // Comment after
+                    b() {}
+
+                    c() {}
+                  }
+                `,
+                dedent`
+                  class Class {
+                    a // Comment after
+
+                    b() {}
+                    c() {}
+                  }
+                `,
+              ],
+              errors: [
+                {
+                  data: {
+                    rightGroup: 'property',
+                    leftGroup: 'method',
+                    right: 'a',
+                    left: 'b',
+                  },
+                  messageId: 'unexpectedClassesGroupOrder',
+                },
+              ],
+              code: dedent`
+                class Class {
+                  b() {}
+                  a // Comment after
+
+                  c() {}
+                }
+              `,
+              options: [
+                {
+                  groups: ['property', 'method'],
+                  newlinesBetween: 'always',
+                },
+              ],
+            },
+          ],
+          valid: [],
+        },
+      )
     })
 
     describe(`${ruleName}(${type}): sorts inline elements correctly`, () => {
diff --git a/test/rules/sort-interfaces.test.ts b/test/rules/sort-interfaces.test.ts
index 363b0cff7..2fda71d19 100644
--- a/test/rules/sort-interfaces.test.ts
+++ b/test/rules/sort-interfaces.test.ts
@@ -2390,6 +2390,61 @@ describe(ruleName, () => {
           valid: [],
         },
       )
+
+      ruleTester.run(
+        `${ruleName}(${type}): handles newlines and comment after fixes`,
+        rule,
+        {
+          invalid: [
+            {
+              output: [
+                dedent`
+                  interface Interface {
+                    a: string // Comment after
+                    b: () => void
+
+                    c: () => void
+                  };
+                `,
+                dedent`
+                  interface Interface {
+                    a: string // Comment after
+
+                    b: () => void
+                    c: () => void
+                  };
+                `,
+              ],
+              errors: [
+                {
+                  data: {
+                    rightGroup: 'property',
+                    leftGroup: 'method',
+                    right: 'a',
+                    left: 'b',
+                  },
+                  messageId: 'unexpectedInterfacePropertiesGroupOrder',
+                },
+              ],
+              code: dedent`
+                interface Interface {
+                  b: () => void
+                  a: string // Comment after
+
+                  c: () => void
+                };
+              `,
+              options: [
+                {
+                  groups: ['property', 'method'],
+                  newlinesBetween: 'always',
+                },
+              ],
+            },
+          ],
+          valid: [],
+        },
+      )
     })
 
     ruleTester.run(
diff --git a/test/rules/sort-object-types.test.ts b/test/rules/sort-object-types.test.ts
index 04b6a990b..fae3833d5 100644
--- a/test/rules/sort-object-types.test.ts
+++ b/test/rules/sort-object-types.test.ts
@@ -2186,6 +2186,61 @@ describe(ruleName, () => {
           valid: [],
         },
       )
+
+      ruleTester.run(
+        `${ruleName}(${type}): handles newlines and comment after fixes`,
+        rule,
+        {
+          invalid: [
+            {
+              output: [
+                dedent`
+                  type Test = {
+                    a: string // Comment after
+                    b: () => void
+
+                    c: () => void
+                  };
+                `,
+                dedent`
+                  type Test = {
+                    a: string // Comment after
+
+                    b: () => void
+                    c: () => void
+                  };
+                `,
+              ],
+              errors: [
+                {
+                  data: {
+                    rightGroup: 'property',
+                    leftGroup: 'method',
+                    right: 'a',
+                    left: 'b',
+                  },
+                  messageId: 'unexpectedObjectTypesGroupOrder',
+                },
+              ],
+              code: dedent`
+                type Test = {
+                  b: () => void
+                  a: string // Comment after
+
+                  c: () => void
+                };
+              `,
+              options: [
+                {
+                  groups: ['property', 'method'],
+                  newlinesBetween: 'always',
+                },
+              ],
+            },
+          ],
+          valid: [],
+        },
+      )
     })
 
     ruleTester.run(
diff --git a/test/rules/sort-objects.test.ts b/test/rules/sort-objects.test.ts
index 3f5510d82..5cfca1bb9 100644
--- a/test/rules/sort-objects.test.ts
+++ b/test/rules/sort-objects.test.ts
@@ -2130,6 +2130,61 @@ describe(ruleName, () => {
           valid: [],
         },
       )
+
+      ruleTester.run(
+        `${ruleName}(${type}): handles newlines and comment after fixes`,
+        rule,
+        {
+          invalid: [
+            {
+              output: [
+                dedent`
+                  let obj = {
+                    a, // Comment after
+                    b() {},
+
+                    c() {},
+                  };
+                `,
+                dedent`
+                  let obj = {
+                    a, // Comment after
+
+                    b() {},
+                    c() {},
+                  };
+                `,
+              ],
+              errors: [
+                {
+                  data: {
+                    rightGroup: 'unknown',
+                    leftGroup: 'method',
+                    right: 'a',
+                    left: 'b',
+                  },
+                  messageId: 'unexpectedObjectsGroupOrder',
+                },
+              ],
+              code: dedent`
+                let obj = {
+                  b() {},
+                  a, // Comment after
+
+                  c() {},
+                };
+              `,
+              options: [
+                {
+                  groups: ['unknown', 'method'],
+                  newlinesBetween: 'always',
+                },
+              ],
+            },
+          ],
+          valid: [],
+        },
+      )
     })
 
     ruleTester.run(
diff --git a/utils/make-order-comments-after-and-newlines-fixes.ts b/utils/make-order-comments-after-and-newlines-fixes.ts
index fb3a3dd9d..267488c68 100644
--- a/utils/make-order-comments-after-and-newlines-fixes.ts
+++ b/utils/make-order-comments-after-and-newlines-fixes.ts
@@ -2,8 +2,9 @@ import type { TSESLint } from '@typescript-eslint/utils'
 
 import type { SortingNode } from '../types/sorting-node'
 
-import { makeOrderAndCommentsAfterFixes } from './make-order-and-comments-after-fixes'
+import { makeCommentAfterFixes } from './make-comment-after-fixes'
 import { makeNewlinesFixes } from './make-newlines-fixes'
+import { makeOrderFixes } from './make-order-fixes'
 
 interface MakeOrderCommentsAfterAndNewlinesFixesParameters {
   options: {
@@ -42,20 +43,30 @@ export let makeOrderCommentsAfterAndNewlinesFixes = ({
   options,
   fixer,
   nodes,
-}: MakeOrderCommentsAfterAndNewlinesFixesParameters): TSESLint.RuleFix[] => [
-  ...makeOrderAndCommentsAfterFixes({
+}: MakeOrderCommentsAfterAndNewlinesFixesParameters): TSESLint.RuleFix[] => {
+  let orderFixes = makeOrderFixes({
     ignoreFirstNodeHighestBlockComment,
     sortedNodes,
     sourceCode,
     options,
+    nodes,
     fixer,
+  })
+  let commentAfterFixes = makeCommentAfterFixes({
+    sortedNodes,
+    sourceCode,
     nodes,
-  }),
-  ...makeNewlinesFixes({
+    fixer,
+  })
+  if (commentAfterFixes.length) {
+    return [...orderFixes, ...commentAfterFixes]
+  }
+  let newlinesFixes = makeNewlinesFixes({
     sortedNodes,
     sourceCode,
     options,
     fixer,
     nodes,
-  }),
-]
+  })
+  return [...orderFixes, ...newlinesFixes]
+}