diff --git a/src/main/java/org/mockito/internal/MockitoCore.java b/src/main/java/org/mockito/internal/MockitoCore.java
index fd39f6a4a2..94dbdec711 100644
--- a/src/main/java/org/mockito/internal/MockitoCore.java
+++ b/src/main/java/org/mockito/internal/MockitoCore.java
@@ -26,10 +26,7 @@
 import static org.mockito.internal.verification.VerificationModeFactory.noMoreInteractions;
 
 import java.util.Arrays;
-import java.util.Collections;
-import java.util.HashSet;
 import java.util.List;
-import java.util.Set;
 import java.util.function.Function;
 
 import org.mockito.InOrder;
@@ -59,7 +56,7 @@
 import org.mockito.invocation.Invocation;
 import org.mockito.invocation.MockHandler;
 import org.mockito.mock.MockCreationSettings;
-import org.mockito.plugins.DoNotMockEnforcer;
+import org.mockito.plugins.DoNotMockEnforcerWithType;
 import org.mockito.plugins.MockMaker;
 import org.mockito.quality.Strictness;
 import org.mockito.stubbing.LenientStubber;
@@ -70,9 +67,8 @@
 @SuppressWarnings("unchecked")
 public class MockitoCore {
 
-    private static final DoNotMockEnforcer DO_NOT_MOCK_ENFORCER = Plugins.getDoNotMockEnforcer();
-    private static final Set<Class<?>> MOCKABLE_CLASSES =
-            Collections.synchronizedSet(new HashSet<>());
+    private static final DoNotMockEnforcerWithType DO_NOT_MOCK_ENFORCER =
+            Plugins.getDoNotMockEnforcer();
 
     public <T> T mock(Class<T> typeToMock, MockSettings settings) {
         if (!(settings instanceof MockSettingsImpl)) {
@@ -84,43 +80,12 @@ public <T> T mock(Class<T> typeToMock, MockSettings settings) {
         }
         MockSettingsImpl impl = (MockSettingsImpl) settings;
         MockCreationSettings<T> creationSettings = impl.build(typeToMock);
-        checkDoNotMockAnnotation(creationSettings.getTypeToMock(), creationSettings);
+        checkDoNotMockAnnotation(creationSettings);
         T mock = createMock(creationSettings);
         mockingProgress().mockingStarted(mock, creationSettings);
         return mock;
     }
 
-    private void checkDoNotMockAnnotation(
-            Class<?> typeToMock, MockCreationSettings<?> creationSettings) {
-        checkDoNotMockAnnotationForType(typeToMock);
-        for (Class<?> aClass : creationSettings.getExtraInterfaces()) {
-            checkDoNotMockAnnotationForType(aClass);
-        }
-    }
-
-    private static void checkDoNotMockAnnotationForType(Class<?> type) {
-        // Object and interfaces do not have a super class
-        if (type == null) {
-            return;
-        }
-
-        if (MOCKABLE_CLASSES.contains(type)) {
-            return;
-        }
-
-        String warning = DO_NOT_MOCK_ENFORCER.checkTypeForDoNotMockViolation(type);
-        if (warning != null) {
-            throw new DoNotMockException(warning);
-        }
-
-        checkDoNotMockAnnotationForType(type.getSuperclass());
-        for (Class<?> aClass : type.getInterfaces()) {
-            checkDoNotMockAnnotationForType(aClass);
-        }
-
-        MOCKABLE_CLASSES.add(type);
-    }
-
     public <T> MockedStatic<T> mockStatic(Class<T> classToMock, MockSettings settings) {
         if (!MockSettingsImpl.class.isInstance(settings)) {
             throw new IllegalArgumentException(
@@ -131,12 +96,20 @@ public <T> MockedStatic<T> mockStatic(Class<T> classToMock, MockSettings setting
         }
         MockSettingsImpl impl = MockSettingsImpl.class.cast(settings);
         MockCreationSettings<T> creationSettings = impl.buildStatic(classToMock);
+        checkDoNotMockAnnotation(creationSettings);
         MockMaker.StaticMockControl<T> control = createStaticMock(classToMock, creationSettings);
         control.enable();
         mockingProgress().mockingStarted(classToMock, creationSettings);
         return new MockedStaticImpl<>(control);
     }
 
+    private void checkDoNotMockAnnotation(MockCreationSettings<?> creationSettings) {
+        String warning = DO_NOT_MOCK_ENFORCER.checkTypeForDoNotMockViolation(creationSettings);
+        if (warning != null) {
+            throw new DoNotMockException(warning);
+        }
+    }
+
     public <T> MockedConstruction<T> mockConstruction(
             Class<T> typeToMock,
             Function<MockedConstruction.Context, ? extends MockSettings> settingsFactory,
diff --git a/src/main/java/org/mockito/internal/configuration/plugins/DefaultMockitoPlugins.java b/src/main/java/org/mockito/internal/configuration/plugins/DefaultMockitoPlugins.java
index c7644257fb..96da9debdc 100644
--- a/src/main/java/org/mockito/internal/configuration/plugins/DefaultMockitoPlugins.java
+++ b/src/main/java/org/mockito/internal/configuration/plugins/DefaultMockitoPlugins.java
@@ -12,7 +12,7 @@
 import org.mockito.MockMakers;
 import org.mockito.internal.util.MockUtil;
 import org.mockito.plugins.AnnotationEngine;
-import org.mockito.plugins.DoNotMockEnforcer;
+import org.mockito.plugins.DoNotMockEnforcerWithType;
 import org.mockito.plugins.InstantiatorProvider2;
 import org.mockito.plugins.MemberAccessor;
 import org.mockito.plugins.MockMaker;
@@ -62,7 +62,7 @@ public class DefaultMockitoPlugins implements MockitoPlugins {
         DEFAULT_PLUGINS.put(
                 REFLECTION_ALIAS, "org.mockito.internal.util.reflection.ReflectionMemberAccessor");
         DEFAULT_PLUGINS.put(
-                DoNotMockEnforcer.class.getName(),
+                DoNotMockEnforcerWithType.class.getName(),
                 "org.mockito.internal.configuration.DefaultDoNotMockEnforcer");
 
         MOCK_MAKER_ALIASES.add(INLINE_ALIAS);
diff --git a/src/main/java/org/mockito/internal/configuration/plugins/PluginRegistry.java b/src/main/java/org/mockito/internal/configuration/plugins/PluginRegistry.java
index 72f5d8e7d5..206da9cdb4 100644
--- a/src/main/java/org/mockito/internal/configuration/plugins/PluginRegistry.java
+++ b/src/main/java/org/mockito/internal/configuration/plugins/PluginRegistry.java
@@ -5,8 +5,10 @@
 package org.mockito.internal.configuration.plugins;
 
 import java.util.List;
+
 import org.mockito.plugins.AnnotationEngine;
 import org.mockito.plugins.DoNotMockEnforcer;
+import org.mockito.plugins.DoNotMockEnforcerWithType;
 import org.mockito.plugins.InstantiatorProvider2;
 import org.mockito.plugins.MemberAccessor;
 import org.mockito.plugins.MockMaker;
@@ -46,8 +48,10 @@ class PluginRegistry {
     private final List<MockResolver> mockResolvers =
             new PluginLoader(pluginSwitch).loadPlugins(MockResolver.class);
 
-    private final DoNotMockEnforcer doNotMockEnforcer =
-            new PluginLoader(pluginSwitch).loadPlugin(DoNotMockEnforcer.class);
+    private final DoNotMockEnforcerWithType doNotMockEnforcer =
+            (DoNotMockEnforcerWithType)
+                    (new PluginLoader(pluginSwitch)
+                            .loadPlugin(DoNotMockEnforcerWithType.class, DoNotMockEnforcer.class));
 
     PluginRegistry() {
         instantiatorProvider =
@@ -119,7 +123,7 @@ MockitoLogger getMockitoLogger() {
      * <p> Returns {@link org.mockito.internal.configuration.DefaultDoNotMockEnforcer} if no
      * {@link DoNotMockEnforcer} extension exists or is visible in the current classpath.</p>
      */
-    DoNotMockEnforcer getDoNotMockEnforcer() {
+    DoNotMockEnforcerWithType getDoNotMockEnforcer() {
         return doNotMockEnforcer;
     }
 
diff --git a/src/main/java/org/mockito/internal/configuration/plugins/Plugins.java b/src/main/java/org/mockito/internal/configuration/plugins/Plugins.java
index 20f6dc7bc6..66ca630304 100644
--- a/src/main/java/org/mockito/internal/configuration/plugins/Plugins.java
+++ b/src/main/java/org/mockito/internal/configuration/plugins/Plugins.java
@@ -4,10 +4,12 @@
  */
 package org.mockito.internal.configuration.plugins;
 
-import org.mockito.DoNotMock;
 import java.util.List;
+
+import org.mockito.DoNotMock;
 import org.mockito.plugins.AnnotationEngine;
 import org.mockito.plugins.DoNotMockEnforcer;
+import org.mockito.plugins.DoNotMockEnforcerWithType;
 import org.mockito.plugins.InstantiatorProvider2;
 import org.mockito.plugins.MemberAccessor;
 import org.mockito.plugins.MockMaker;
@@ -16,7 +18,9 @@
 import org.mockito.plugins.MockitoPlugins;
 import org.mockito.plugins.StackTraceCleanerProvider;
 
-/** Access to Mockito behavior that can be reconfigured by plugins */
+/**
+ * Access to Mockito behavior that can be reconfigured by plugins
+ */
 public final class Plugins {
 
     private static final PluginRegistry registry = new PluginRegistry();
@@ -99,9 +103,10 @@ public static MockitoPlugins getPlugins() {
      * Returns the {@link DoNotMock} enforcer available for the current runtime.
      *
      * <p> Returns {@link org.mockito.internal.configuration.DefaultDoNotMockEnforcer} if no
-     * {@link DoNotMockEnforcer} extension exists or is visible in the current classpath.</p>
+     * {@link DoNotMockEnforcerWithType} or {@link DoNotMockEnforcer} extension exists or is visible
+     * in the current classpath.</p>
      */
-    public static DoNotMockEnforcer getDoNotMockEnforcer() {
+    public static DoNotMockEnforcerWithType getDoNotMockEnforcer() {
         return registry.getDoNotMockEnforcer();
     }
 
diff --git a/src/main/java/org/mockito/internal/creation/MockSettingsImpl.java b/src/main/java/org/mockito/internal/creation/MockSettingsImpl.java
index 7bef7764d4..4088efb307 100644
--- a/src/main/java/org/mockito/internal/creation/MockSettingsImpl.java
+++ b/src/main/java/org/mockito/internal/creation/MockSettingsImpl.java
@@ -34,6 +34,7 @@
 import org.mockito.listeners.VerificationStartedListener;
 import org.mockito.mock.MockCreationSettings;
 import org.mockito.mock.MockName;
+import org.mockito.mock.MockType;
 import org.mockito.mock.SerializableMode;
 import org.mockito.quality.Strictness;
 import org.mockito.stubbing.Answer;
@@ -283,9 +284,7 @@ private static <T> CreationSettings<T> validatedSettings(
         // TODO SF - I don't think we really need CreationSettings type
         // TODO do we really need to copy the entire settings every time we create mock object? it
         // does not seem necessary.
-        CreationSettings<T> settings = new CreationSettings<T>(source);
-        settings.setMockName(new MockNameImpl(source.getName(), typeToMock, false));
-        settings.setTypeToMock(typeToMock);
+        CreationSettings<T> settings = buildCreationSettings(typeToMock, source, MockType.INSTANCE);
         settings.setExtraInterfaces(prepareExtraInterfaces(source));
         return settings;
     }
@@ -306,9 +305,15 @@ private static <T> CreationSettings<T> validatedStaticSettings(
                     "Cannot specify spied instance for static mock of " + classToMock);
         }
 
-        CreationSettings<T> settings = new CreationSettings<T>(source);
-        settings.setMockName(new MockNameImpl(source.getName(), classToMock, true));
+        return buildCreationSettings(classToMock, source, MockType.STATIC);
+    }
+
+    private static <T> CreationSettings<T> buildCreationSettings(
+            Class<T> classToMock, CreationSettings<T> source, MockType mockType) {
+        CreationSettings<T> settings = new CreationSettings<>(source);
+        settings.setMockName(new MockNameImpl(source.getName(), classToMock, mockType));
         settings.setTypeToMock(classToMock);
+        settings.setMockType(mockType);
         return settings;
     }
 
diff --git a/src/main/java/org/mockito/internal/creation/settings/CreationSettings.java b/src/main/java/org/mockito/internal/creation/settings/CreationSettings.java
index 51544fb9e0..253ca99684 100644
--- a/src/main/java/org/mockito/internal/creation/settings/CreationSettings.java
+++ b/src/main/java/org/mockito/internal/creation/settings/CreationSettings.java
@@ -18,6 +18,7 @@
 import org.mockito.listeners.VerificationStartedListener;
 import org.mockito.mock.MockCreationSettings;
 import org.mockito.mock.MockName;
+import org.mockito.mock.MockType;
 import org.mockito.mock.SerializableMode;
 import org.mockito.quality.Strictness;
 import org.mockito.stubbing.Answer;
@@ -49,6 +50,7 @@ public class CreationSettings<T> implements MockCreationSettings<T>, Serializabl
     private Object[] constructorArgs;
     protected Strictness strictness = null;
     protected String mockMaker;
+    protected MockType mockType;
 
     public CreationSettings() {}
 
@@ -73,6 +75,7 @@ public CreationSettings(CreationSettings copy) {
         this.strictness = copy.strictness;
         this.stripAnnotations = copy.stripAnnotations;
         this.mockMaker = copy.mockMaker;
+        this.mockType = copy.mockType;
     }
 
     @Override
@@ -198,4 +201,13 @@ public String getMockMaker() {
     public Type getGenericTypeToMock() {
         return genericTypeToMock;
     }
+
+    @Override
+    public MockType getMockType() {
+        return mockType;
+    }
+
+    public void setMockType(MockType mockType) {
+        this.mockType = mockType;
+    }
 }
diff --git a/src/main/java/org/mockito/internal/util/MockNameImpl.java b/src/main/java/org/mockito/internal/util/MockNameImpl.java
index 6374687698..41917c657a 100644
--- a/src/main/java/org/mockito/internal/util/MockNameImpl.java
+++ b/src/main/java/org/mockito/internal/util/MockNameImpl.java
@@ -7,6 +7,7 @@
 import java.io.Serializable;
 
 import org.mockito.mock.MockName;
+import org.mockito.mock.MockType;
 
 public class MockNameImpl implements MockName, Serializable {
 
@@ -15,9 +16,9 @@ public class MockNameImpl implements MockName, Serializable {
     private boolean defaultName;
 
     @SuppressWarnings("unchecked")
-    public MockNameImpl(String mockName, Class<?> type, boolean mockedStatic) {
+    public MockNameImpl(String mockName, Class<?> type, MockType mockType) {
         if (mockName == null) {
-            this.mockName = mockedStatic ? toClassName(type) : toInstanceName(type);
+            this.mockName = mockType == MockType.STATIC ? toClassName(type) : toInstanceName(type);
             this.defaultName = true;
         } else {
             this.mockName = mockName;
diff --git a/src/main/java/org/mockito/mock/MockCreationSettings.java b/src/main/java/org/mockito/mock/MockCreationSettings.java
index 949af03b2e..8d5631535d 100644
--- a/src/main/java/org/mockito/mock/MockCreationSettings.java
+++ b/src/main/java/org/mockito/mock/MockCreationSettings.java
@@ -151,4 +151,12 @@ public interface MockCreationSettings<T> {
      * @since 4.8.0
      */
     String getMockMaker();
+
+    /**
+     * Returns the {@link MockType} for the mock being created.
+     *
+     * @see MockType
+     * @since 5.9.0
+     */
+    MockType getMockType();
 }
diff --git a/src/main/java/org/mockito/mock/MockType.java b/src/main/java/org/mockito/mock/MockType.java
new file mode 100644
index 0000000000..e2a7b4fd92
--- /dev/null
+++ b/src/main/java/org/mockito/mock/MockType.java
@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2024 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.mock;
+
+/**
+ * The type of mock being created
+ */
+public enum MockType {
+
+    /**
+     * Mock created as an instance of the mocked type
+     */
+    INSTANCE,
+
+    /**
+     * Mock replaces the mocked type through static mocking
+     */
+    STATIC,
+}
diff --git a/src/main/java/org/mockito/plugins/DoNotMockEnforcer.java b/src/main/java/org/mockito/plugins/DoNotMockEnforcer.java
index a033bbce58..bc3c77a014 100644
--- a/src/main/java/org/mockito/plugins/DoNotMockEnforcer.java
+++ b/src/main/java/org/mockito/plugins/DoNotMockEnforcer.java
@@ -4,20 +4,96 @@
  */
 package org.mockito.plugins;
 
+import org.mockito.NotExtensible;
+import org.mockito.mock.MockCreationSettings;
+
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+
 /**
  * Enforcer that is applied to every type in the type hierarchy of the class-to-be-mocked.
  */
-public interface DoNotMockEnforcer {
+public interface DoNotMockEnforcer extends DoNotMockEnforcerWithType {
 
     /**
-     * If this type is allowed to be mocked. Return an empty optional if the enforcer allows
+     * Check whether this type is allowed to be mocked. Return {@code null} if the enforcer allows
      * this type to be mocked. Return a message if there is a reason this type can not be mocked.
-     *
-     * Note that Mockito performs traversal of the type hierarchy. Implementations of this class
-     * should therefore not perform type traversal themselves but rely on Mockito.
+     * <p>
+     * Note that traversal of the type hierarchy is performed externally to this method.
+     * Implementations of it should therefore not perform type traversal themselves.
      *
      * @param type The type to check
-     * @return Optional message if this type can not be mocked, or an empty optional if type can be mocked
+     * @return Optional message if this type can not be mocked, or {@code null} otherwise
+     * @see #checkTypeForDoNotMockViolation(MockCreationSettings)
      */
     String checkTypeForDoNotMockViolation(Class<?> type);
+
+    /**
+     * Check whether this type is allowed to be mocked. Return {@code null} if the enforcer allows
+     * this type to be mocked. Return a message if there is a reason this type can not be mocked.
+     * <p>
+     * The default implementation traverses the class hierarchy of the type to be mocked and
+     * checks it against {@link #checkTypeForDoNotMockViolation(Class)}. If any types fails
+     * the validation, the traversal is interrupted and the error message is returned.
+     *
+     * @param creationSettings The mock creation settings
+     * @return Optional message if this type can not be mocked, or {@code null} otherwise
+     * @since 5.9.0
+     */
+    @Override
+    default String checkTypeForDoNotMockViolation(MockCreationSettings<?> creationSettings) {
+        String warning = recursiveCheckDoNotMockAnnotationForType(creationSettings.getTypeToMock());
+        if (warning != null) {
+            return warning;
+        }
+
+        for (Class<?> aClass : creationSettings.getExtraInterfaces()) {
+            warning = recursiveCheckDoNotMockAnnotationForType(aClass);
+            if (warning != null) {
+                return warning;
+            }
+        }
+
+        return null;
+    }
+
+    private String recursiveCheckDoNotMockAnnotationForType(Class<?> type) {
+        // Object and interfaces do not have a super class
+        if (type == null) {
+            return null;
+        }
+
+        if (Cache.MOCKABLE_TYPES.contains(type)) {
+            return null;
+        }
+
+        String warning = checkTypeForDoNotMockViolation(type);
+        if (warning != null) {
+            return warning;
+        }
+
+        warning = recursiveCheckDoNotMockAnnotationForType(type.getSuperclass());
+        if (warning != null) {
+            return warning;
+        }
+
+        for (Class<?> aClass : type.getInterfaces()) {
+            warning = recursiveCheckDoNotMockAnnotationForType(aClass);
+            if (warning != null) {
+                return warning;
+            }
+        }
+
+        Cache.MOCKABLE_TYPES.add(type);
+        return null;
+    }
+
+    /**
+     * Static cache for types that are known to be mockable and
+     * thus may be skipped while traversing the class hierarchy.
+     */
+    @NotExtensible
+    class Cache {
+        private static final Set<Class<?>> MOCKABLE_TYPES = ConcurrentHashMap.newKeySet();
+    }
 }
diff --git a/src/main/java/org/mockito/plugins/DoNotMockEnforcerWithType.java b/src/main/java/org/mockito/plugins/DoNotMockEnforcerWithType.java
new file mode 100644
index 0000000000..5bbff900c7
--- /dev/null
+++ b/src/main/java/org/mockito/plugins/DoNotMockEnforcerWithType.java
@@ -0,0 +1,24 @@
+/*
+ * Copyright (c) 2024 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.plugins;
+
+import org.mockito.mock.MockCreationSettings;
+
+/**
+ * Enforcer that checks if a mock can be created given its type and other settings used in its creation.
+ *
+ * @since 5.9.0
+ */
+public interface DoNotMockEnforcerWithType {
+
+    /**
+     * Check whether this type is allowed to be mocked. Return {@code null} if the enforcer allows
+     * this type to be mocked. Return a message if there is a reason this type can not be mocked.
+     *
+     * @param creationSettings The mock creation settings
+     * @return Optional message if this type can not be mocked, or {@code null} otherwise
+     */
+    String checkTypeForDoNotMockViolation(MockCreationSettings<?> creationSettings);
+}
diff --git a/src/test/java/org/mockito/internal/util/MockNameImplTest.java b/src/test/java/org/mockito/internal/util/MockNameImplTest.java
index 583bd7ac06..28e8f96ed3 100644
--- a/src/test/java/org/mockito/internal/util/MockNameImplTest.java
+++ b/src/test/java/org/mockito/internal/util/MockNameImplTest.java
@@ -7,6 +7,7 @@
 import static org.junit.Assert.assertEquals;
 
 import org.junit.Test;
+import org.mockito.mock.MockType;
 import org.mockitoutil.TestBase;
 
 public class MockNameImplTest extends TestBase {
@@ -14,7 +15,7 @@ public class MockNameImplTest extends TestBase {
     @Test
     public void shouldProvideTheNameForClass() throws Exception {
         // when
-        String name = new MockNameImpl(null, SomeClass.class, false).toString();
+        String name = new MockNameImpl(null, SomeClass.class, MockType.INSTANCE).toString();
         // then
         assertEquals("someClass", name);
     }
@@ -22,7 +23,7 @@ public void shouldProvideTheNameForClass() throws Exception {
     @Test
     public void shouldProvideTheNameForClassOnStaticMock() throws Exception {
         // when
-        String name = new MockNameImpl(null, SomeClass.class, true).toString();
+        String name = new MockNameImpl(null, SomeClass.class, MockType.STATIC).toString();
         // then
         assertEquals("SomeClass.class", name);
     }
@@ -32,7 +33,8 @@ public void shouldProvideTheNameForAnonymousClass() throws Exception {
         // given
         SomeInterface anonymousInstance = new SomeInterface() {};
         // when
-        String name = new MockNameImpl(null, anonymousInstance.getClass(), false).toString();
+        String name =
+                new MockNameImpl(null, anonymousInstance.getClass(), MockType.INSTANCE).toString();
         // then
         assertEquals("someInterface", name);
     }
@@ -42,7 +44,8 @@ public void shouldProvideTheNameForAnonymousClassOnStatic() throws Exception {
         // given
         SomeInterface anonymousInstance = new SomeInterface() {};
         // when
-        String name = new MockNameImpl(null, anonymousInstance.getClass(), true).toString();
+        String name =
+                new MockNameImpl(null, anonymousInstance.getClass(), MockType.STATIC).toString();
         // then
         assertEquals("SomeInterface$.class", name);
     }
@@ -50,7 +53,7 @@ public void shouldProvideTheNameForAnonymousClassOnStatic() throws Exception {
     @Test
     public void shouldProvideTheGivenName() throws Exception {
         // when
-        String name = new MockNameImpl("The Hulk", SomeClass.class, false).toString();
+        String name = new MockNameImpl("The Hulk", SomeClass.class, MockType.INSTANCE).toString();
         // then
         assertEquals("The Hulk", name);
     }
@@ -58,7 +61,7 @@ public void shouldProvideTheGivenName() throws Exception {
     @Test
     public void shouldProvideTheGivenNameOnStatic() throws Exception {
         // when
-        String name = new MockNameImpl("The Hulk", SomeClass.class, true).toString();
+        String name = new MockNameImpl("The Hulk", SomeClass.class, MockType.STATIC).toString();
         // then
         assertEquals("The Hulk", name);
     }
diff --git a/src/test/java/org/mockitousage/annotation/DoNotMockTest.java b/src/test/java/org/mockitousage/annotation/DoNotMockTest.java
index 9364345369..14fe814d92 100644
--- a/src/test/java/org/mockitousage/annotation/DoNotMockTest.java
+++ b/src/test/java/org/mockitousage/annotation/DoNotMockTest.java
@@ -6,10 +6,12 @@
 
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
 import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.mockStatic;
 
 import org.junit.Test;
 import org.mockito.DoNotMock;
 import org.mockito.Mock;
+import org.mockito.MockedStatic;
 import org.mockito.MockitoAnnotations;
 import org.mockito.exceptions.misusing.DoNotMockException;
 
@@ -24,6 +26,15 @@ public void can_not_mock_class_annotated_with_donotmock() {
                 .isInstanceOf(DoNotMockException.class);
     }
 
+    @Test
+    public void can_not_statically_mock_class_annotated_with_donotmock() {
+        assertThatThrownBy(
+                        () -> {
+                            MockedStatic<NotMockable> notMockable = mockStatic(NotMockable.class);
+                        })
+                .isInstanceOf(DoNotMockException.class);
+    }
+
     @Test
     public void can_not_mock_class_via_mock_annotation() {
         assertThatThrownBy(
@@ -43,6 +54,16 @@ public void can_not_mock_class_with_interface_annotated_with_donotmock() {
                 .isInstanceOf(DoNotMockException.class);
     }
 
+    @Test
+    public void can_not_statically_mock_class_with_interface_annotated_with_donotmock() {
+        assertThatThrownBy(
+                        () -> {
+                            MockedStatic<SubclassOfNotMockableInterface> notMockable =
+                                    mockStatic(SubclassOfNotMockableInterface.class);
+                        })
+                .isInstanceOf(DoNotMockException.class);
+    }
+
     @Test
     public void can_not_mock_subclass_with_unmockable_interface() {
         assertThatThrownBy(
@@ -53,6 +74,16 @@ public void can_not_mock_subclass_with_unmockable_interface() {
                 .isInstanceOf(DoNotMockException.class);
     }
 
+    @Test
+    public void can_not_statically_mock_subclass_with_unmockable_interface() {
+        assertThatThrownBy(
+                        () -> {
+                            MockedStatic<DoubleSubclassOfInterface> notMockable =
+                                    mockStatic(DoubleSubclassOfInterface.class);
+                        })
+                .isInstanceOf(DoNotMockException.class);
+    }
+
     @Test
     public void can_not_mock_subclass_with_unmockable_superclass() {
         assertThatThrownBy(
@@ -63,6 +94,16 @@ public void can_not_mock_subclass_with_unmockable_superclass() {
                 .isInstanceOf(DoNotMockException.class);
     }
 
+    @Test
+    public void can_not_statically_mock_subclass_with_unmockable_superclass() {
+        assertThatThrownBy(
+                        () -> {
+                            MockedStatic<SubclassOfNotMockableSuperclass> notMockable =
+                                    mockStatic(SubclassOfNotMockableSuperclass.class);
+                        })
+                .isInstanceOf(DoNotMockException.class);
+    }
+
     @Test
     public void
             can_not_mock_subclass_with_unmockable_interface_that_extends_non_mockable_interface() {
@@ -74,6 +115,17 @@ public void can_not_mock_subclass_with_unmockable_superclass() {
                 .isInstanceOf(DoNotMockException.class);
     }
 
+    @Test
+    public void
+            can_not_statically_mock_subclass_with_unmockable_interface_that_extends_non_mockable_interface() {
+        assertThatThrownBy(
+                        () -> {
+                            MockedStatic<SubclassOfSubInterfaceOfNotMockableInterface> notMockable =
+                                    mockStatic(SubclassOfSubInterfaceOfNotMockableInterface.class);
+                        })
+                .isInstanceOf(DoNotMockException.class);
+    }
+
     @Test
     public void thrown_exception_includes_non_mockable_reason() {
         assertThatThrownBy(
@@ -94,6 +146,17 @@ public void thrown_exception_includes_special_non_mockable_reason() {
                 .hasMessageContaining("Special reason");
     }
 
+    @Test
+    public void thrown_exception_includes_special_non_mockable_reason_static() {
+        assertThatThrownBy(
+                        () -> {
+                            MockedStatic<NotMockableWithReason> notMockable =
+                                    mockStatic(NotMockableWithReason.class);
+                        })
+                .isInstanceOf(DoNotMockException.class)
+                .hasMessageContaining("Special reason");
+    }
+
     @Test
     public void can_not_mock_class_with_custom_donotmock_annotation() {
         assertThatThrownBy(
@@ -104,6 +167,16 @@ public void can_not_mock_class_with_custom_donotmock_annotation() {
                 .isInstanceOf(DoNotMockException.class);
     }
 
+    @Test
+    public void can_not_statically_mock_class_with_custom_donotmock_annotation() {
+        assertThatThrownBy(
+                        () -> {
+                            MockedStatic<NotMockableWithDifferentAnnotation> notMockable =
+                                    mockStatic(NotMockableWithDifferentAnnotation.class);
+                        })
+                .isInstanceOf(DoNotMockException.class);
+    }
+
     @DoNotMock
     private static class NotMockable {}
 
diff --git a/subprojects/extTest/src/test/java/org/mockitousage/plugins/donotmockenforcer/DoNotmockEnforcerTest.java b/subprojects/extTest/src/test/java/org/mockitousage/plugins/donotmockenforcer/DoNotmockEnforcerTest.java
index 4c631e6090..5649610c87 100644
--- a/subprojects/extTest/src/test/java/org/mockitousage/plugins/donotmockenforcer/DoNotmockEnforcerTest.java
+++ b/subprojects/extTest/src/test/java/org/mockitousage/plugins/donotmockenforcer/DoNotmockEnforcerTest.java
@@ -6,9 +6,12 @@
 
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
 import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.mockStatic;
 
 import org.junit.Test;
 import org.mockito.DoNotMock;
+import org.mockito.MockedStatic;
+import org.mockito.exceptions.base.MockitoException;
 import org.mockito.exceptions.misusing.DoNotMockException;
 
 public class DoNotmockEnforcerTest {
@@ -27,6 +30,50 @@ public void uses_custom_enforcer_allows_special_cased_class() {
         NotMockableButSpecialCased notMockable = mock(NotMockableButSpecialCased.class);
     }
 
+    @Test
+    public void uses_custom_enforcer_allows_statically_non_mockable() {
+        StaticallyNotMockable notMockable = mock(StaticallyNotMockable.class);
+    }
+
+    @Test
+    public void uses_custom_enforcer_disallows_static_mocks_of_type_with_specific_name() {
+        assertThatThrownBy(
+                        () -> {
+                            MockedStatic<StaticallyNotMockable> notMockable =
+                                    mockStatic(StaticallyNotMockable.class);
+                        })
+                .isInstanceOf(DoNotMockException.class)
+                .hasMessage("Cannot mockStatic!");
+    }
+
+    @Test
+    public void
+            uses_custom_enforcer_disallows_static_mocks_of_type_that_inherits_from_non_statically_mockable() {
+        assertThatThrownBy(
+                        () -> {
+                            MockedStatic<StaticallyNotMockableChild> notMockable =
+                                    mockStatic(StaticallyNotMockableChild.class);
+                        })
+                .isInstanceOf(DoNotMockException.class)
+                .hasMessage("Cannot mockStatic!");
+    }
+
+    @Test
+    public void uses_custom_enforcer_allows_static_mocks_of_type_with_specific_name() {
+        /*
+         Current MockMaker does not support static mocks, so asserting we get its exception rather than
+         a DoNotMockException is enough to assert the DoNotMockEnforcer let it through.
+        */
+        assertThatThrownBy(
+                        () -> {
+                            MockedStatic<StaticallyMockable> notMockable =
+                                    mockStatic(StaticallyMockable.class);
+                        })
+                .isInstanceOf(MockitoException.class)
+                .isNotInstanceOf(DoNotMockException.class)
+                .hasMessageContaining("does not support the creation of static mocks");
+    }
+
     @Test
     public void uses_custom_enforcer_has_custom_message() {
         assertThatThrownBy(
@@ -41,4 +88,10 @@ static class NotMockable {}
 
     @DoNotMock
     static class NotMockableButSpecialCased {}
+
+    static class StaticallyNotMockable {}
+
+    static class StaticallyNotMockableChild extends StaticallyNotMockable {}
+
+    static class StaticallyMockable {}
 }
diff --git a/subprojects/extTest/src/test/java/org/mockitousage/plugins/donotmockenforcer/MyDoNotMockEnforcer.java b/subprojects/extTest/src/test/java/org/mockitousage/plugins/donotmockenforcer/MyDoNotMockEnforcer.java
index 73ca830173..ae450806e0 100644
--- a/subprojects/extTest/src/test/java/org/mockitousage/plugins/donotmockenforcer/MyDoNotMockEnforcer.java
+++ b/subprojects/extTest/src/test/java/org/mockitousage/plugins/donotmockenforcer/MyDoNotMockEnforcer.java
@@ -4,6 +4,8 @@
  */
 package org.mockitousage.plugins.donotmockenforcer;
 
+import org.mockito.mock.MockCreationSettings;
+import org.mockito.mock.MockType;
 import org.mockito.plugins.DoNotMockEnforcer;
 
 public class MyDoNotMockEnforcer implements DoNotMockEnforcer {
@@ -14,9 +16,28 @@ public String checkTypeForDoNotMockViolation(Class<?> type) {
         if (type.getName().endsWith("NotMockableButSpecialCased")) {
             return null;
         }
+        // Special case for allowing StaticallyNotMockable to still be used for regular mocks
+        if (type.getName().endsWith("StaticallyNotMockable")) {
+            return null;
+        }
         if (type.getName().startsWith("org.mockitousage.plugins.donotmockenforcer")) {
             return "Custom message!";
         }
         return null;
     }
+
+    @Override
+    public String checkTypeForDoNotMockViolation(MockCreationSettings<?> creationSettings) {
+        if (creationSettings.getMockType() == MockType.STATIC) {
+            Class<?> type = creationSettings.getTypeToMock();
+            if (type.getName().endsWith("StaticallyMockable")) {
+                return null;
+            }
+            if (type.getName().startsWith("org.mockitousage.plugins.donotmockenforcer")) {
+                return "Cannot mockStatic!";
+            }
+            return null;
+        }
+        return DoNotMockEnforcer.super.checkTypeForDoNotMockViolation(creationSettings);
+    }
 }