diff --git a/mypy/checker.py b/mypy/checker.py
--- a/mypy/checker.py
+++ b/mypy/checker.py
@@ -1104,7 +1104,17 @@ def check___new___signature(self, fdef: FuncDef, typ: CallableType) -> None:
         bound_type = bind_self(typ, self_type, is_classmethod=True)
         # Check that __new__ (after binding cls) returns an instance
         # type (or any).
-        if not isinstance(get_proper_type(bound_type.ret_type),
+        if isinstance(fdef.info, TypeInfo) and fdef.info.is_metaclass():
+            # This is a metaclass, so it must return a new unrelated type.
+            self.check_subtype(
+                bound_type.ret_type,
+                self.type_type(),
+                fdef,
+                message_registry.INVALID_NEW_TYPE,
+                'returns',
+                'but must return a subtype of'
+            )
+        elif not isinstance(get_proper_type(bound_type.ret_type),
                           (AnyType, Instance, TupleType)):
             self.fail(
                 message_registry.NON_INSTANCE_NEW_TYPE.format(

diff --git a/test-data/unit/check-classes.test b/test-data/unit/check-classes.test
--- a/test-data/unit/check-classes.test
+++ b/test-data/unit/check-classes.test
@@ -6419,6 +6419,37 @@ class B(A):
 
 reveal_type(B())  # N: Revealed type is "__main__.B"
 
+[case testNewReturnType10]
+# https://github.com/python/mypy/issues/11398
+from typing import Type
+
+class MyMetaClass(type):
+    def __new__(cls, name, bases, attrs) -> Type['MyClass']:
+        pass
+
+class MyClass(metaclass=MyMetaClass):
+    pass
+
+[case testNewReturnType11]
+# https://github.com/python/mypy/issues/11398
+class MyMetaClass(type):
+    def __new__(cls, name, bases, attrs) -> type:
+        pass
+
+class MyClass(metaclass=MyMetaClass):
+    pass
+
+[case testNewReturnType12]
+# https://github.com/python/mypy/issues/11398
+from typing import Type
+
+class MyMetaClass(type):
+    def __new__(cls, name, bases, attrs) -> int:  # E: Incompatible return type for "__new__" (returns "int", but must return a subtype of "type")
+        pass
+
+class MyClass(metaclass=MyMetaClass):
+    pass
+
 [case testGenericOverride]
 from typing import Generic, TypeVar, Any
 

enhance the comprehension of the `__new__` method of a metaclass
**Feature**

The `__new__` method of a Metaclass should be hinted as returning a specific `Type`.

**Pitch**

```python

class MyPool:
    registry: Dict[str, Type[MyAbstractClass]] = {}
    
    @classmethod
    def register(cls, the_class):
        cls.registry[the_class.__name__] = the_class

class MyMetaClass(type):
    def __new__(cls, name, bases, attrs) -> Type[MyAbstractClass]:
        if not bases:
            return super().__new__(name, bases, attrs)
        new_class = super().__new__(name, bases, attrs)
        # do something with new_class. in my case:
        MyPool.register(new_class)
        return new_class

class MyAbstractClass(metaclass=MyMetaClass):
    pass

class MyRealClass(MyAbstractClass):
    pass
```

Currently, mypy will say: `"__new__" must return a class instance (got "Type[MyAbstractClass]")`

mypy/test/testcheck.py::TypeCheckSuite::testNewReturnType10 mypy/test/testcheck.py::TypeCheckSuite::testNewReturnType11 mypy/test/testcheck.py::TypeCheckSuite::testNewReturnType12
mypy/test/testcheck.py::TypeCheckSuite::testGenericOverridePreciseValid mypy/test/testcheck.py::TypeCheckSuite::testGenericOverridePreciseInvalid mypy/test/testcheck.py::TypeCheckSuite::testGenericOverride mypy/test/testcheck.py::TypeCheckSuite::testGenericOverrideGenericChained mypy/test/testcheck.py::TypeCheckSuite::testGenericOverrideGeneric