diff --git a/mypy/expandtype.py b/mypy/expandtype.py
index f704df3b010e..246bb848cad6 100644
--- a/mypy/expandtype.py
+++ b/mypy/expandtype.py
@@ -250,9 +250,9 @@ def visit_type_var(self, t: TypeVarType) -> Type:
             if (tvar_id := repl.id) in self.recursive_tvar_guard:
                 return self.recursive_tvar_guard[tvar_id] or repl
             self.recursive_tvar_guard[tvar_id] = None
-            repl = repl.accept(self)
-            if isinstance(repl, TypeVarType):
-                repl.default = repl.default.accept(self)
+            repl.default = repl.default.accept(self)
+            expanded = repl.accept(self)  # Note: `expanded is repl` may be true.
+            repl = repl if isinstance(expanded, TypeVarType) else expanded
             self.recursive_tvar_guard[tvar_id] = repl
         return repl
 
diff --git a/test-data/unit/check-typevar-defaults.test b/test-data/unit/check-typevar-defaults.test
index 22270e17787e..103c0e782797 100644
--- a/test-data/unit/check-typevar-defaults.test
+++ b/test-data/unit/check-typevar-defaults.test
@@ -416,6 +416,38 @@ def func_c4(
     reveal_type(m)  # N: Revealed type is "__main__.ClassC4[builtins.int, builtins.float]"
 [builtins fixtures/tuple.pyi]
 
+[case testTypeVarDefaultsSwap]
+from typing import TypeVar, Generic
+
+T = TypeVar("T")
+X = TypeVar("X", default=object)
+Y = TypeVar("Y", default=object)
+
+
+class Foo(Generic[T, Y]):
+    def test(self) -> None:
+        reveal_type( Foo[Y, T]() )  # N: Revealed type is "__main__.Foo[Y`2 = builtins.object, T`1]"
+
+
+class Bar(Generic[X, Y]):
+    def test(self) -> None:
+        reveal_type( Bar[Y, X]() )  # N: Revealed type is "__main__.Bar[Y`2 = builtins.object, X`1 = builtins.object]"
+
+
+[case testTypeVarDefaultsSwap2]
+from typing import TypeVar, Generic
+
+X = TypeVar("X", default=object)
+Y = TypeVar("Y", default=object)
+U = TypeVar("U", default=object)
+V = TypeVar("V", default=object)
+
+class Transform(Generic[X, Y]):
+    def invert(self) -> "Transform[Y, X]": ...
+
+class Foo(Transform[U, V], Generic[U, V]):
+    def invert(self) -> "Foo[V, U]": ...
+
 [case testTypeVarDefaultsClassRecursive1]
 # flags: --disallow-any-generics
 from typing import Generic, TypeVar, List