diff --git a/core/src/main/java/org/jdbi/v3/core/extension/UnableToCreateExtensionException.java b/core/src/main/java/org/jdbi/v3/core/extension/UnableToCreateExtensionException.java
index d29818da5c..ac698addbe 100644
--- a/core/src/main/java/org/jdbi/v3/core/extension/UnableToCreateExtensionException.java
+++ b/core/src/main/java/org/jdbi/v3/core/extension/UnableToCreateExtensionException.java
@@ -46,4 +46,8 @@ public UnableToCreateExtensionException(String format, Object... args) {
     public UnableToCreateExtensionException(Throwable throwable, String format, Object... args) {
         super(format(format, args), throwable);
     }
+
+    public UnableToCreateExtensionException(Throwable cause) {
+        super(cause);
+    }
 }
diff --git a/core/src/main/java/org/jdbi/v3/core/internal/OnDemandExtensions.java b/core/src/main/java/org/jdbi/v3/core/internal/OnDemandExtensions.java
index 10cc7d2d5a..95ccbc3a52 100644
--- a/core/src/main/java/org/jdbi/v3/core/internal/OnDemandExtensions.java
+++ b/core/src/main/java/org/jdbi/v3/core/internal/OnDemandExtensions.java
@@ -13,20 +13,18 @@
  */
 package org.jdbi.v3.core.internal;
 
-import java.lang.invoke.MethodHandle;
 import java.lang.invoke.MethodHandles;
 import java.lang.reflect.InvocationHandler;
 import java.lang.reflect.Method;
 import java.lang.reflect.Proxy;
 import java.util.Arrays;
+import java.util.LinkedHashSet;
 import java.util.Optional;
-import java.util.function.Function;
-import java.util.stream.Stream;
 
 import org.jdbi.v3.core.Jdbi;
 import org.jdbi.v3.core.config.JdbiConfig;
 import org.jdbi.v3.core.extension.Extensions;
-import org.jdbi.v3.core.internal.exceptions.Unchecked;
+import org.jdbi.v3.core.internal.exceptions.Sneaky;
 
 import static org.jdbi.v3.core.internal.JdbiClassUtils.EQUALS_METHOD;
 import static org.jdbi.v3.core.internal.JdbiClassUtils.HASHCODE_METHOD;
@@ -73,23 +71,25 @@ private Object createProxy(Jdbi jdbi, Class<?> extensionType, Class<?>... extraT
             return jdbi.withExtension(extensionType, extension -> invoke(extension, method, args));
         };
 
-        Class<?>[] types = Stream.of(
-                Stream.of(extensionType),
-                Arrays.stream(extensionType.getInterfaces()),
-                Arrays.stream(extraTypes))
-            .flatMap(Function.identity())
-            .distinct()
-            .toArray(Class[]::new);
-        return Proxy.newProxyInstance(extensionType.getClassLoader(), types, handler);
+        var types = new LinkedHashSet<Class<?>>();
+        types.add(extensionType);
+        types.addAll(Arrays.asList(extensionType.getInterfaces()));
+        types.addAll(Arrays.asList(extraTypes));
+        return Proxy.newProxyInstance(extensionType.getClassLoader(), types.toArray(new Class<?>[0]), handler);
     }
 
     private static Object invoke(Object target, Method method, Object[] args) {
-        if (Proxy.isProxyClass(target.getClass())) {
-            InvocationHandler handler = Proxy.getInvocationHandler(target);
-            return Unchecked.<Object[], Object>function(params -> handler.invoke(target, method, params)).apply(args);
-        } else {
-            MethodHandle handle = Unchecked.function(MethodHandles.lookup()::unreflect).apply(method).bindTo(target);
-            return Unchecked.<Object[], Object>function(handle::invokeWithArguments).apply(args);
+        try {
+            if (Proxy.isProxyClass(target.getClass())) {
+                return Proxy.getInvocationHandler(target)
+                        .invoke(target, method, args);
+            } else {
+                return MethodHandles.lookup().unreflect(method)
+                        .bindTo(target)
+                        .invokeWithArguments(args);
+            }
+        } catch (Throwable t) {
+            throw Sneaky.throwAnyway(t);
         }
     }