diff --git a/CHANGELOG.md b/CHANGELOG.md
index 5d33ee327..9781f289c 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -13,6 +13,8 @@ This document follows the conventions laid out in [Keep a CHANGELOG][].
 
 ### Fixed
 
+-   Fixed objects leaking when Python attached event handlers to them even if they were later removed
+
 
 ## [3.0.0](https://github.com/pythonnet/pythonnet/releases/tag/v3.0.0) - 2022-09-29
 
diff --git a/src/embed_tests/Events.cs b/src/embed_tests/Events.cs
new file mode 100644
index 000000000..c216f4214
--- /dev/null
+++ b/src/embed_tests/Events.cs
@@ -0,0 +1,67 @@
+using System;
+using System.Diagnostics;
+using System.Threading;
+
+using NUnit.Framework;
+
+using Python.Runtime;
+
+namespace Python.EmbeddingTest;
+
+public class Events
+{
+    [OneTimeSetUp]
+    public void SetUp()
+    {
+        PythonEngine.Initialize();
+    }
+
+    [OneTimeTearDown]
+    public void Dispose()
+    {
+        PythonEngine.Shutdown();
+    }
+
+    [Test]
+    public void UsingDoesNotLeak()
+    {
+        using var scope = Py.CreateScope();
+        scope.Exec(@"
+import gc
+
+from Python.EmbeddingTest import ClassWithEventHandler
+
+def event_handler():
+    pass
+
+for _ in range(2000):
+    example = ClassWithEventHandler()
+    example.LeakEvent += event_handler
+    example.LeakEvent -= event_handler
+    del example
+
+gc.collect()
+");
+        Runtime.Runtime.TryCollectingGarbage(10);
+        Assert.AreEqual(0, ClassWithEventHandler.alive);
+    }
+}
+
+public class ClassWithEventHandler
+{
+    internal static int alive;
+
+    public event EventHandler LeakEvent;
+    private Array arr;  // dummy array to exacerbate memory leak
+
+    public ClassWithEventHandler()
+    {
+        Interlocked.Increment(ref alive);
+        this.arr = new int[800];
+    }
+
+    ~ClassWithEventHandler()
+    {
+        Interlocked.Decrement(ref alive);
+    }
+}
diff --git a/src/runtime/Finalizer.cs b/src/runtime/Finalizer.cs
index f4b465ecb..713564f08 100644
--- a/src/runtime/Finalizer.cs
+++ b/src/runtime/Finalizer.cs
@@ -364,6 +364,8 @@ struct PendingFinalization
     {
         public IntPtr PyObj;
         public BorrowedReference Ref => new(PyObj);
+        public ManagedType? Managed => ManagedType.GetManagedObject(Ref);
+        public nint RefCount => Runtime.Refcount(Ref);
         public int RuntimeRun;
 #if TRACE_ALLOC
         public string StackTrace;
diff --git a/src/runtime/PythonTypes/PyObject.cs b/src/runtime/PythonTypes/PyObject.cs
index ce86753eb..bda2d9c02 100644
--- a/src/runtime/PythonTypes/PyObject.cs
+++ b/src/runtime/PythonTypes/PyObject.cs
@@ -1051,9 +1051,20 @@ public PyList Dir()
             return Runtime.GetManagedString(strval.BorrowOrThrow());
         }
 
-        string? DebuggerDisplay => DebugUtil.HaveInterpreterLock()
-            ? this.ToString()
-            : $"pyobj at 0x{this.rawPtr:X} (get Py.GIL to see more info)";
+        ManagedType? InternalManagedObject => ManagedType.GetManagedObject(this.Reference);
+
+        string? DebuggerDisplay
+        {
+            get
+            {
+                if (DebugUtil.HaveInterpreterLock())
+                    return this.ToString();
+                var obj = this.InternalManagedObject;
+                return obj is { }
+                    ? obj.ToString()
+                    : $"pyobj at 0x{this.rawPtr:X} (get Py.GIL to see more info)";
+            }
+        }
 
 
         /// <summary>
diff --git a/src/runtime/Util/CodeGenerator.cs b/src/runtime/Util/CodeGenerator.cs
index 35a637113..6e0859da0 100644
--- a/src/runtime/Util/CodeGenerator.cs
+++ b/src/runtime/Util/CodeGenerator.cs
@@ -1,5 +1,7 @@
 using System;
 using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
 using System.Reflection;
 using System.Reflection.Emit;
 using System.Threading;
@@ -17,13 +19,15 @@ internal class CodeGenerator
         private readonly AssemblyBuilder aBuilder;
         private readonly ModuleBuilder mBuilder;
 
+        const string NamePrefix = "__Python_Runtime_Generated_";
+
         internal CodeGenerator()
         {
-            var aname = new AssemblyName { Name = "__CodeGenerator_Assembly" };
+            var aname = new AssemblyName { Name = GetUniqueAssemblyName(NamePrefix + "Assembly") };
             var aa = AssemblyBuilderAccess.Run;
 
             aBuilder = Thread.GetDomain().DefineDynamicAssembly(aname, aa);
-            mBuilder = aBuilder.DefineDynamicModule("__CodeGenerator_Module");
+            mBuilder = aBuilder.DefineDynamicModule(NamePrefix + "Module");
         }
 
         /// <summary>
@@ -77,5 +81,20 @@ internal static void GenerateMarshalByRefsBack(ILGenerator il, IReadOnlyList<Typ
                 }
             }
         }
+
+        static string GetUniqueAssemblyName(string name)
+        {
+            var taken = new HashSet<string>(AppDomain.CurrentDomain
+                                                     .GetAssemblies()
+                                                     .Select(a => a.GetName().Name));
+            for (int i = 0; i < int.MaxValue; i++)
+            {
+                string candidate = name + i.ToString(CultureInfo.InvariantCulture);
+                if (!taken.Contains(candidate))
+                    return candidate;
+            }
+
+            throw new NotSupportedException("Too many assemblies");
+        }
     }
 }
diff --git a/src/runtime/Util/EventHandlerCollection.cs b/src/runtime/Util/EventHandlerCollection.cs
index 551893799..0cd03d0fd 100644
--- a/src/runtime/Util/EventHandlerCollection.cs
+++ b/src/runtime/Util/EventHandlerCollection.cs
@@ -99,6 +99,10 @@ internal bool RemoveEventHandler(BorrowedReference target, BorrowedReference han
                 continue;
             }
             list.RemoveAt(i);
+            if (list.Count == 0)
+            {
+                Remove(key);
+            }
             return true;
         }