diff --git a/Tomlet.Tests/DeliberatelyIncorrectTestResources.Designer.cs b/Tomlet.Tests/DeliberatelyIncorrectTestResources.Designer.cs
index 8052348..d4b98e3 100644
--- a/Tomlet.Tests/DeliberatelyIncorrectTestResources.Designer.cs
+++ b/Tomlet.Tests/DeliberatelyIncorrectTestResources.Designer.cs
@@ -141,6 +141,12 @@ internal static string KeyRedefinitionViaTableTestInput {
             }
         }
         
+        internal static string EnumKeyRedefinitionViaTableTestInput {
+            get {
+                return ResourceManager.GetString("EnumKeyRedefinitionViaTableTestInput", resourceCulture);
+            }
+        }
+        
         internal static string ReDefiningSubTableAsSubTableArrayTestInput {
             get {
                 return ResourceManager.GetString("ReDefiningSubTableAsSubTableArrayTestInput", resourceCulture);
diff --git a/Tomlet.Tests/DeliberatelyIncorrectTestResources.resx b/Tomlet.Tests/DeliberatelyIncorrectTestResources.resx
index 14993b7..6ae1090 100644
--- a/Tomlet.Tests/DeliberatelyIncorrectTestResources.resx
+++ b/Tomlet.Tests/DeliberatelyIncorrectTestResources.resx
@@ -81,6 +81,15 @@ apple = "red"
 
 [fruit.apple]
 texture = "smooth"</value>
+    </data>
+    <data name="EnumKeyRedefinitionViaTableTestInput" xml:space="preserve">
+        <value>[Subnames]
+[Subnames.Value1]
+a = 'A'
+b = 'B'
+[Subnames.Value1]
+a = 'A'
+b = 'B'</value>
     </data>
     <data name="ReDefiningSubTableAsSubTableArrayTestInput" xml:space="preserve">
         <value># INVALID TOML DOC
diff --git a/Tomlet.Tests/EnumTests.cs b/Tomlet.Tests/EnumTests.cs
index c8166f7..8cca0cc 100644
--- a/Tomlet.Tests/EnumTests.cs
+++ b/Tomlet.Tests/EnumTests.cs
@@ -64,7 +64,16 @@ public void CanDeserializeEnumDictionary()
         var expected = new Dictionary<TestEnum, int> {{TestEnum.Value1, 1}, {TestEnum.Value2, 2}, {TestEnum.Value3, 3}};
         Assert.Equal(expected, result);
     }
-
+    
+    [Fact]
+    public void CanIgnoreInvalidEnumDictionaryKeys()
+    {
+        var toml = "Value1 = 1\nValue2 = 2\nValue3 = 3\nValue4 = 4\nValue5 = 5\nValue6 = 6\n";
+        var result = TomletMain.To<Dictionary<TestEnum, int>>(toml, new TomlSerializerOptions { IgnoreInvalidEnumValues = true });
+        var expected = new Dictionary<TestEnum, int> {{TestEnum.Value1, 1}, {TestEnum.Value2, 2}, {TestEnum.Value3, 3}};
+        Assert.Equal(expected, result);
+    }
+    
     [Fact]
     public void CanDeserializeEnumDictionaryWithFields()
     {
diff --git a/Tomlet.Tests/ExceptionTests.cs b/Tomlet.Tests/ExceptionTests.cs
index 1865244..e334d2a 100644
--- a/Tomlet.Tests/ExceptionTests.cs
+++ b/Tomlet.Tests/ExceptionTests.cs
@@ -109,6 +109,10 @@ public void ReDefiningASubTableAsASubTableArrayThrowsAnException() =>
     public void RedefiningAKeyAsATableNameThrowsAnException() => 
         AssertThrows<TomlKeyRedefinitionException>(() => GetDocument(DeliberatelyIncorrectTestResources.KeyRedefinitionViaTableTestInput));
     
+    [Fact]
+    public void RedefiningAnEnumKeyAsATableEntryThrowsAnException() => 
+        AssertThrows<TomlTableRedefinitionException>(() => GetDocument(DeliberatelyIncorrectTestResources.EnumKeyRedefinitionViaTableTestInput));
+    
     [Fact]
     public void DefiningATableArrayWithTheSameNameAsATableThrowsAnException() => 
         AssertThrows<TomlTableArrayAlreadyExistsAsNonArrayException>(() => GetDocument(DeliberatelyIncorrectTestResources.DefiningAsArrayWhenAlreadyTableTestInput));
diff --git a/Tomlet/TomlSerializationMethods.cs b/Tomlet/TomlSerializationMethods.cs
index d3ac220..cee4b8e 100644
--- a/Tomlet/TomlSerializationMethods.cs
+++ b/Tomlet/TomlSerializationMethods.cs
@@ -388,28 +388,32 @@ private static Deserialize<Dictionary<TKey, TValue>> PrimitiveKeyedDictionaryDes
             if (value is not TomlTable table)
                 throw new TomlTypeMismatchException(typeof(TomlTable), value.GetType(), typeof(Dictionary<TKey, TValue>));
 
-            return table.Entries.ToDictionary(
-                entry =>
+            return table.Entries
+                .Where(entry =>
                 {
-                    if (!type.IsEnum)
-                    {
-                        return (TKey)(entry.Key as IConvertible).ToType(typeof(TKey), CultureInfo.InvariantCulture);
-                    }
+                    if (!type.IsEnum || !options.IgnoreInvalidEnumValues)
+                        return true;
 
                     try
                     {
-                        return (TKey)Enum.Parse(type, entry.Key, true);
+                        _ = Enum.Parse(type, entry.Key, true);
+                        return true;
                     }
                     catch (ArgumentException)
                     {
-                        if (options.IgnoreInvalidEnumValues)
-                            return (TKey)Enum.GetValues(type).GetValue(0)!;
-
-                        throw new TomlEnumParseException(entry.Key, typeof(TKey));
+                        return false;
                     }
+                })
+                .ToDictionary(entry =>
+                {
+                    if (!type.IsEnum)
+                    {
+                        return (TKey)(entry.Key as IConvertible).ToType(typeof(TKey), CultureInfo.InvariantCulture);
+                    }
+
+                    return (TKey)Enum.Parse(type, entry.Key, true);
                 },
-                entry => (TValue)valueDeserializer(entry.Value)
-            );
+                entry => (TValue)valueDeserializer(entry.Value));
         };
     }
 
diff --git a/Tomlet/TomlSerializerOptions.cs b/Tomlet/TomlSerializerOptions.cs
index 37daa9a..0cdcf87 100644
--- a/Tomlet/TomlSerializerOptions.cs
+++ b/Tomlet/TomlSerializerOptions.cs
@@ -17,5 +17,8 @@ public class TomlSerializerOptions
     /// <summary>
     /// When set to true, the deserializer will ignore invalid enum values (and they will be implicitly left at their default value). When set to false, an exception will be thrown if the enum value is not found.
     /// </summary>
+    /// <remarks>
+    /// When deserializing dictionaries with enums as keys, invalid enum values will be skipped.
+    /// </remarks>
     public bool IgnoreInvalidEnumValues { get; set; } = false;
 }
\ No newline at end of file