diff --git a/docs/workflow/trimming/feature-switches.md b/docs/workflow/trimming/feature-switches.md
index 40971d1fdb9df5..36ac156f4f86be 100644
--- a/docs/workflow/trimming/feature-switches.md
+++ b/docs/workflow/trimming/feature-switches.md
@@ -19,6 +19,7 @@ configurations but their defaults might vary as any SDK can set the defaults dif
 | StartupHookSupport | System.StartupHookProvider.IsSupported | Startup hooks are disabled when set to false. Startup hook related functionality can be trimmed. |
 | TBD | System.Threading.ThreadPool.EnableDispatchAutoreleasePool | When set to true, creates an NSAutoreleasePool around each thread pool work item on applicable platforms. |
 | CustomResourceTypesSupport | System.Resources.ResourceManager.AllowCustomResourceTypes | Use of custom resource types is disabled when set to false. ResourceManager code paths that use reflection for custom types can be trimmed. |
+| EnableUnsafeBinaryFormatterInDesigntimeLicenseContextSerialization | System.ComponentModel.TypeConverter.EnableUnsafeBinaryFormatterInDesigntimeLicenseContextSerialization | BinaryFormatter serialization support is trimmed when set to false. |
 
 Any feature-switch which defines property can be set in csproj file or
 on the command line as any other MSBuild property. Those without predefined property name
diff --git a/eng/testing/linker/project.csproj.template b/eng/testing/linker/project.csproj.template
index 7ac21cbcb5b5f0..53576a8cc2163d 100644
--- a/eng/testing/linker/project.csproj.template
+++ b/eng/testing/linker/project.csproj.template
@@ -29,6 +29,7 @@
 
   <ItemGroup>
     {AdditionalProjectReferences}
+    {TrimmerRootAssemblies}
   </ItemGroup>
 
   <!-- Logic to override the default IlLink tasks that come from the SDK and use the one
diff --git a/eng/testing/linker/trimmingTests.targets b/eng/testing/linker/trimmingTests.targets
index 0473cfcd03636c..51ef745179af99 100644
--- a/eng/testing/linker/trimmingTests.targets
+++ b/eng/testing/linker/trimmingTests.targets
@@ -66,6 +66,11 @@
       <_additionalProjectSourceFiles Include="%(TestConsoleApps.AdditionalSourceFiles)" />
     </ItemGroup>
 
+    <PropertyGroup>
+      <_TrimmerRootAssemblies>%(TestConsoleApps.TrimmerRootAssemblies)</_TrimmerRootAssemblies>
+      <_TrimmerRootAssemblies Condition="'$(_TrimmerRootAssemblies)' != ''">&lt;TrimmerRootAssembly Include=&quot;$(_TrimmerRootAssemblies)&quot; /&gt;</_TrimmerRootAssemblies>
+    </PropertyGroup>
+
     <MakeDir Directories="$(_projectDir)" />
     <WriteLinesToFile File="$(_projectFile)"
                       Lines="$([System.IO.File]::ReadAllText('$(ProjectTemplate)')
@@ -77,6 +82,7 @@
                                                  .Replace('{MicrosoftNETILLinkTasksVersion}', '$(MicrosoftNETILLinkTasksVersion)')
                                                  .Replace('{ExtraTrimmerArgs}', '%(TestConsoleApps.ExtraTrimmerArgs)')
                                                  .Replace('{AdditionalProjectReferences}', '$(_additionalProjectReferencesString)')
+                                                 .Replace('{TrimmerRootAssemblies}', '$(_TrimmerRootAssemblies)')
                                                  .Replace('{RepositoryEngineeringDir}', '$(RepositoryEngineeringDir)')
                                                  .Replace('{MonoAOTCompilerDir}', '$(MonoAOTCompilerDir)')
                                                  .Replace('{MonoProjectRoot}', '$(MonoProjectRoot)')
diff --git a/src/libraries/System.ComponentModel.TypeConverter/src/ILLink/ILLink.Substitutions.xml b/src/libraries/System.ComponentModel.TypeConverter/src/ILLink/ILLink.Substitutions.xml
new file mode 100644
index 00000000000000..d5df6acfa1cbc4
--- /dev/null
+++ b/src/libraries/System.ComponentModel.TypeConverter/src/ILLink/ILLink.Substitutions.xml
@@ -0,0 +1,7 @@
+<linker>
+  <assembly fullname="System.ComponentModel.TypeConverter">
+    <type fullname="System.ComponentModel.Design.DesigntimeLicenseContextSerializer" feature="System.ComponentModel.TypeConverter.EnableUnsafeBinaryFormatterInDesigntimeLicenseContextSerialization" featurevalue="false">
+      <method signature="System.Boolean get_EnableUnsafeBinaryFormatterInDesigntimeLicenseContextSerialization()" body="stub" value="false" />
+    </type>
+  </assembly>
+</linker>
diff --git a/src/libraries/System.ComponentModel.TypeConverter/src/ILLink/ILLink.Suppressions.xml b/src/libraries/System.ComponentModel.TypeConverter/src/ILLink/ILLink.Suppressions.xml
index 9a250687a3b2ac..47dfa8195d7be5 100644
--- a/src/libraries/System.ComponentModel.TypeConverter/src/ILLink/ILLink.Suppressions.xml
+++ b/src/libraries/System.ComponentModel.TypeConverter/src/ILLink/ILLink.Suppressions.xml
@@ -1,18 +1,6 @@
 <?xml version="1.0" encoding="utf-8"?>
 <linker>
   <assembly fullname="System.ComponentModel.TypeConverter, PublicKeyToken=b03f5f7f11d50a3a">
-    <attribute fullname="System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute">
-      <argument>ILLink</argument>
-      <argument>IL2026</argument>
-      <property name="Scope">member</property>
-      <property name="Target">M:System.ComponentModel.Design.DesigntimeLicenseContextSerializer.Deserialize(System.IO.Stream,System.String,System.ComponentModel.Design.RuntimeLicenseContext)</property>
-    </attribute>
-    <attribute fullname="System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute">
-      <argument>ILLink</argument>
-      <argument>IL2026</argument>
-      <property name="Scope">member</property>
-      <property name="Target">M:System.ComponentModel.Design.DesigntimeLicenseContextSerializer.Serialize(System.IO.Stream,System.String,System.ComponentModel.Design.DesigntimeLicenseContext)</property>
-    </attribute>
     <attribute fullname="System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute">
       <argument>ILLink</argument>
       <argument>IL2072</argument>
diff --git a/src/libraries/System.ComponentModel.TypeConverter/src/Resources/Strings.resx b/src/libraries/System.ComponentModel.TypeConverter/src/Resources/Strings.resx
index 7de9810d591ed2..e9dd12b50616dd 100644
--- a/src/libraries/System.ComponentModel.TypeConverter/src/Resources/Strings.resx
+++ b/src/libraries/System.ComponentModel.TypeConverter/src/Resources/Strings.resx
@@ -250,4 +250,7 @@
   <data name="MemberRelationshipService_RelationshipNotSupported" xml:space="preserve">
     <value>Relationships between {0}.{1} and {2}.{3} are not supported.</value>
   </data>
+  <data name="BinaryFormatterMessage" xml:space="preserve">
+    <value>BinaryFormatter serialization is obsolete and should not be used. See https://aka.ms/binaryformatter for more information.</value>
+  </data>
 </root>
\ No newline at end of file
diff --git a/src/libraries/System.ComponentModel.TypeConverter/src/System.ComponentModel.TypeConverter.csproj b/src/libraries/System.ComponentModel.TypeConverter/src/System.ComponentModel.TypeConverter.csproj
index 7319c74b19b825..a93c8e4aadc9da 100644
--- a/src/libraries/System.ComponentModel.TypeConverter/src/System.ComponentModel.TypeConverter.csproj
+++ b/src/libraries/System.ComponentModel.TypeConverter/src/System.ComponentModel.TypeConverter.csproj
@@ -4,6 +4,9 @@
     <IsPartialFacadeAssembly>true</IsPartialFacadeAssembly>
     <TargetFrameworks>$(NetCoreAppCurrent)</TargetFrameworks>
   </PropertyGroup>
+  <ItemGroup>
+    <ILLinkSubstitutionsXmls Include="$(ILLinkDirectory)ILLink.Substitutions.xml" />
+  </ItemGroup>
   <ItemGroup>
     <Compile Include="MS\Internal\Xml\Linq\ComponentModel\XComponentModel.cs" />
     <Compile Include="System\ComponentModel\ArrayConverter.cs" />
diff --git a/src/libraries/System.ComponentModel.TypeConverter/src/System/ComponentModel/Design/DesigntimeLicenseContextSerializer.cs b/src/libraries/System.ComponentModel.TypeConverter/src/System/ComponentModel/Design/DesigntimeLicenseContextSerializer.cs
index c4e7c24165e779..75f17a28c649c6 100644
--- a/src/libraries/System.ComponentModel.TypeConverter/src/System/ComponentModel/Design/DesigntimeLicenseContextSerializer.cs
+++ b/src/libraries/System.ComponentModel.TypeConverter/src/System/ComponentModel/Design/DesigntimeLicenseContextSerializer.cs
@@ -5,6 +5,7 @@
 using System.Runtime.Serialization;
 using System.Collections;
 using System.IO;
+using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
 
 namespace System.ComponentModel.Design
@@ -14,6 +15,10 @@ namespace System.ComponentModel.Design
     /// </summary>
     public class DesigntimeLicenseContextSerializer
     {
+        internal const byte BinaryWriterMagic = 255;
+
+        private static bool EnableUnsafeBinaryFormatterInDesigntimeLicenseContextSerialization { get; } = AppContext.TryGetSwitch("System.ComponentModel.TypeConverter.EnableUnsafeBinaryFormatterInDesigntimeLicenseContextSerialization", out bool isEnabled) ? isEnabled : false;
+
         // Not creatable.
         private DesigntimeLicenseContextSerializer()
         {
@@ -24,26 +29,156 @@ private DesigntimeLicenseContextSerializer()
         /// using the specified key and output stream.
         /// </summary>
         public static void Serialize(Stream o, string cryptoKey, DesigntimeLicenseContext context)
+        {
+            if (EnableUnsafeBinaryFormatterInDesigntimeLicenseContextSerialization)
+            {
+                SerializeWithBinaryFormatter(o, cryptoKey, context);
+            }
+            else
+            {
+                using (BinaryWriter writer = new BinaryWriter(o, encoding: Text.Encoding.UTF8, leaveOpen: true))
+                {
+                    writer.Write(BinaryWriterMagic); // flag to identify BinaryWriter
+                    writer.Write(cryptoKey);
+                    writer.Write(context._savedLicenseKeys.Count);
+                    foreach (DictionaryEntry keyAndValue in context._savedLicenseKeys)
+                    {
+                        writer.Write(keyAndValue.Key.ToString());
+                        writer.Write(keyAndValue.Value.ToString());
+                    }
+                }
+            }
+        }
+
+        [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:RequiresUnreferencedCode",
+            Justification = "Only simple types (string and HashTable) are serialized with BinaryFormatter. These types can be serialized in a trimmed application.")]
+        private static void SerializeWithBinaryFormatter(Stream o, string cryptoKey, DesigntimeLicenseContext context)
         {
             IFormatter formatter = new BinaryFormatter();
-#pragma warning disable SYSLIB0011 // Issue https://github.com/dotnet/runtime/issues/39293 tracks finding an alternative to BinaryFormatter
+#pragma warning disable SYSLIB0011
             formatter.Serialize(o, new object[] { cryptoKey, context._savedLicenseKeys });
 #pragma warning restore SYSLIB0011
         }
 
-        internal static void Deserialize(Stream o, string cryptoKey, RuntimeLicenseContext context)
+        private class StreamWrapper : Stream
         {
-#pragma warning disable SYSLIB0011 // Issue https://github.com/dotnet/runtime/issues/39293 tracks finding an alternative to BinaryFormatter
-            IFormatter formatter = new BinaryFormatter();
+            private Stream _stream;
+            private bool _readFirstByte;
+            internal byte _firstByte;
+            public StreamWrapper(Stream stream)
+            {
+                _stream = stream;
+                _readFirstByte = false;
+                _firstByte = 0;
+            }
+
+            public override bool CanRead => _stream.CanRead;
+
+            public override bool CanSeek => _stream.CanSeek;
+
+            public override bool CanWrite => _stream.CanWrite;
+
+            public override long Length => _stream.Length;
+
+            public override long Position { get => _stream.Position; set => _stream.Position = value; }
+
+            public override void Flush() => _stream.Flush();
+
+            public override int Read(byte[] buffer, int offset, int count)
+            {
+                Debug.Assert(_stream.Position != 0, "Expected the first byte to be read first");
+                if (_stream.Position == 1)
+                {
+                    Debug.Assert(_readFirstByte == true);
+                    // Add the first byte read by ReadByte into buffer here
+                    buffer[offset] = _firstByte;
+                    return _stream.Read(buffer, offset + 1, count - 1) + 1;
+                }
+                return _stream.Read(buffer, offset, count);
+            }
+
+            public override long Seek(long offset, SeekOrigin origin) => _stream.Seek(offset, origin);
+
+            public override void SetLength(long value) => _stream.SetLength(value);
 
-            object obj = formatter.Deserialize(o);
+            public override void Write(byte[] buffer, int offset, int count) => _stream.Write(buffer, offset, count);
+
+            public override int ReadByte()
+            {
+                byte read = (byte)_stream.ReadByte();
+                _firstByte = read;
+                _readFirstByte = true;
+                return read;
+            }
+        }
+
+        /// <summary>
+        /// During deserialization, the stream passed in may be binary formatted or may have used binary writer. This is a quick test to discern between them.
+        /// </summary>
+        private static bool StreamIsBinaryFormatted(StreamWrapper stream)
+        {
+            // For binary formatter, the first byte is the SerializationHeaderRecord and has a value 0
+            int firstByte = stream.ReadByte();
+            if (firstByte != 0)
+            {
+                return false;
+            }
+
+            return true;
+        }
+
+        [DynamicDependency(DynamicallyAccessedMemberTypes.NonPublicConstructors, typeof(Hashtable))]
+        [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:RequiresUnreferencedCode",
+            Justification = "HashTable's Serialization ctor will be preserved by the DynamicDependency.")]
+        private static void DeserializeUsingBinaryFormatter(StreamWrapper wrappedStream, string cryptoKey, RuntimeLicenseContext context)
+        {
+            if (EnableUnsafeBinaryFormatterInDesigntimeLicenseContextSerialization)
+            {
+#pragma warning disable SYSLIB0011
+                IFormatter formatter = new BinaryFormatter();
+
+                object obj = formatter.Deserialize(wrappedStream);
 #pragma warning restore SYSLIB0011
 
-            if (obj is object[] value)
+                if (obj is object[] value)
+                {
+                    if (value[0] is string && (string)value[0] == cryptoKey)
+                    {
+                        context._savedLicenseKeys = (Hashtable)value[1];
+                    }
+                }
+            }
+            else
+            {
+                throw new NotSupportedException(SR.BinaryFormatterMessage);
+            }
+        }
+
+        internal static void Deserialize(Stream o, string cryptoKey, RuntimeLicenseContext context)
+        {
+            StreamWrapper wrappedStream = new StreamWrapper(o);
+            if (StreamIsBinaryFormatted(wrappedStream))
+            {
+                DeserializeUsingBinaryFormatter(wrappedStream, cryptoKey, context);
+            }
+            else
             {
-                if (value[0] is string && (string)value[0] == cryptoKey)
+                using (BinaryReader reader = new BinaryReader(wrappedStream, encoding: Text.Encoding.UTF8, leaveOpen: true))
                 {
-                    context._savedLicenseKeys = (Hashtable)value[1];
+                    byte binaryWriterIdentifer = wrappedStream._firstByte;
+                    Debug.Assert(binaryWriterIdentifer == BinaryWriterMagic, $"Expected the first byte to be {BinaryWriterMagic}");
+                    string streamCryptoKey = reader.ReadString();
+                    int numEntries = reader.ReadInt32();
+                    if (streamCryptoKey == cryptoKey)
+                    {
+                        context._savedLicenseKeys.Clear();
+                        for (int i = 0; i < numEntries; i++)
+                        {
+                            string key = reader.ReadString();
+                            string value = reader.ReadString();
+                            context._savedLicenseKeys.Add(key, value);
+                        }
+                    }
                 }
             }
         }
diff --git a/src/libraries/System.ComponentModel.TypeConverter/tests/Design/DesigntimeLicenseContextSerializerTests.cs b/src/libraries/System.ComponentModel.TypeConverter/tests/Design/DesigntimeLicenseContextSerializerTests.cs
new file mode 100644
index 00000000000000..131d6f73c4e28a
--- /dev/null
+++ b/src/libraries/System.ComponentModel.TypeConverter/tests/Design/DesigntimeLicenseContextSerializerTests.cs
@@ -0,0 +1,140 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Collections;
+using System.IO;
+using System.Reflection;
+using Microsoft.DotNet.RemoteExecutor;
+using Xunit;
+
+namespace System.ComponentModel.Design.Tests
+{
+    public static class DesigntimeLicenseContextSerializerTests
+    {
+        private const string enableBinaryFormatterInTypeConverter = "System.ComponentModel.TypeConverter.EnableUnsafeBinaryFormatterInDesigntimeLicenseContextSerialization";
+        private const string enableBinaryFormatter = "System.Runtime.Serialization.EnableUnsafeBinaryFormatterSerialization";
+
+        public static bool AreBinaryFormatterAndRemoteExecutorSupportedOnThisPlatform => PlatformDetection.IsBinaryFormatterSupported && RemoteExecutor.IsSupported;
+
+        private static void VerifyStreamFormatting(Stream stream)
+        {
+            AppContext.TryGetSwitch(enableBinaryFormatterInTypeConverter, out bool binaryFormatterUsageInTypeConverterIsEnabled);
+            long position = stream.Position;
+            int firstByte = stream.ReadByte();
+            if (binaryFormatterUsageInTypeConverterIsEnabled)
+            {
+                Assert.Equal(0, firstByte);
+            }
+            else
+            {
+                Assert.Equal(255, firstByte);
+            }
+            stream.Seek(position, SeekOrigin.Begin);
+        }
+
+        [ConditionalTheory(nameof(AreBinaryFormatterAndRemoteExecutorSupportedOnThisPlatform))]
+        [InlineData(false, "key")]
+        [InlineData(true, "key")]
+        [InlineData(false, "")]
+        [InlineData(true, "")]
+        public static void SerializeAndDeserialize(bool useBinaryFormatter, string key)
+        {
+            RemoteInvokeOptions options = new RemoteInvokeOptions();
+            if (useBinaryFormatter)
+            {
+                options.RuntimeConfigurationOptions.Add(enableBinaryFormatterInTypeConverter, bool.TrueString);
+            }
+            RemoteExecutor.Invoke((key) =>
+            {
+                var context = new DesigntimeLicenseContext();
+                context.SetSavedLicenseKey(typeof(int), key);
+                var assembly = typeof(DesigntimeLicenseContextSerializer).Assembly;
+                Type runtimeLicenseContextType = assembly.GetType("System.ComponentModel.Design.RuntimeLicenseContext");
+                Assert.NotNull(runtimeLicenseContextType);
+                object runtimeLicenseContext = Activator.CreateInstance(runtimeLicenseContextType);
+                FieldInfo _savedLicenseKeys = runtimeLicenseContextType.GetField("_savedLicenseKeys", BindingFlags.NonPublic | BindingFlags.Instance);
+                Assert.NotNull(_savedLicenseKeys);
+                _savedLicenseKeys.SetValue(runtimeLicenseContext, new Hashtable());
+                Assert.NotNull(runtimeLicenseContext);
+
+                Type designtimeLicenseContextSerializer = assembly.GetType("System.ComponentModel.Design.DesigntimeLicenseContextSerializer");
+                Assert.NotNull(designtimeLicenseContextSerializer);
+                MethodInfo deserializeMethod = designtimeLicenseContextSerializer.GetMethod("Deserialize", BindingFlags.NonPublic | BindingFlags.Static);
+
+                using (MemoryStream stream = new MemoryStream())
+                {
+                    long position = stream.Position;
+                    DesigntimeLicenseContextSerializer.Serialize(stream, key, context);
+                    stream.Seek(position, SeekOrigin.Begin);
+                    VerifyStreamFormatting(stream);
+                    deserializeMethod.Invoke(null, new object[] { stream, key, runtimeLicenseContext });
+                    Hashtable savedLicenseKeys = runtimeLicenseContext.GetType().GetField("_savedLicenseKeys", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(runtimeLicenseContext) as Hashtable;
+                    Assert.NotNull(savedLicenseKeys);
+                    var value = savedLicenseKeys[typeof(int).AssemblyQualifiedName];
+                    Assert.True(value is string);
+                    Assert.Equal(key, value);
+                }
+            }, key, options).Dispose();
+        }
+
+        [ConditionalTheory(nameof(AreBinaryFormatterAndRemoteExecutorSupportedOnThisPlatform))]
+        [InlineData("key")]
+        [InlineData("")]
+        public static void SerializeWithBinaryFormatter_DeserializeWithBinaryWriter(string key)
+        {
+            AppContext.SetSwitch(enableBinaryFormatter, true);
+            AppContext.SetSwitch(enableBinaryFormatterInTypeConverter, true);
+            var context = new DesigntimeLicenseContext();
+            context.SetSavedLicenseKey(typeof(int), key);
+            string tempPath = Path.GetTempPath();
+            try
+            {
+
+                using (MemoryStream stream = new MemoryStream())
+                {
+                    long position = stream.Position;
+                    DesigntimeLicenseContextSerializer.Serialize(stream, key, context);
+                    stream.Seek(position, SeekOrigin.Begin);
+                    VerifyStreamFormatting(stream);
+
+                    using (FileStream outStream = File.Create(Path.Combine(tempPath, "_temp_SerializeWithBinaryFormatter_DeserializeWithBinaryWriter")))
+                    {
+                        stream.Seek(position, SeekOrigin.Begin);
+                        stream.CopyTo(outStream);
+                    }
+                }
+
+                RemoteInvokeHandle handle = RemoteExecutor.Invoke((key) =>
+                {
+                    var assembly = typeof(DesigntimeLicenseContextSerializer).Assembly;
+                    Type runtimeLicenseContextType = assembly.GetType("System.ComponentModel.Design.RuntimeLicenseContext");
+                    Assert.NotNull(runtimeLicenseContextType);
+                    object runtimeLicenseContext = Activator.CreateInstance(runtimeLicenseContextType);
+                    Assert.NotNull(runtimeLicenseContext);
+                    FieldInfo _savedLicenseKeys = runtimeLicenseContextType.GetField("_savedLicenseKeys", BindingFlags.NonPublic | BindingFlags.Instance);
+                    Assert.NotNull(_savedLicenseKeys);
+                    _savedLicenseKeys.SetValue(runtimeLicenseContext, new Hashtable());
+
+                    Type designtimeLicenseContextSerializer = assembly.GetType("System.ComponentModel.Design.DesigntimeLicenseContextSerializer");
+                    Assert.NotNull(designtimeLicenseContextSerializer);
+                    MethodInfo deserializeMethod = designtimeLicenseContextSerializer.GetMethod("Deserialize", BindingFlags.NonPublic | BindingFlags.Static);
+                    Assert.NotNull(deserializeMethod);
+
+                    string tempPath = Path.GetTempPath();
+                    using (FileStream stream = File.Open(Path.Combine(tempPath, "_temp_SerializeWithBinaryFormatter_DeserializeWithBinaryWriter"), FileMode.Open))
+                    {
+                        TargetInvocationException exception = Assert.Throws<TargetInvocationException>(() => deserializeMethod.Invoke(null, new object[] { stream, key, runtimeLicenseContext }));
+                        Assert.IsType<NotSupportedException>(exception.InnerException);
+                    }
+                }, key);
+
+                handle.Process.WaitForExit();
+                handle.Dispose();
+            }
+            finally
+            {
+                File.Delete(Path.Combine(tempPath, "_temp_SerializeWithBinaryFormatter_DeserializeWithBinaryWriter"));
+            }
+        }
+    }
+}
diff --git a/src/libraries/System.ComponentModel.TypeConverter/tests/System.ComponentModel.TypeConverter.Tests.csproj b/src/libraries/System.ComponentModel.TypeConverter/tests/System.ComponentModel.TypeConverter.Tests.csproj
index 49f136f0c0b974..645e898ea5150c 100644
--- a/src/libraries/System.ComponentModel.TypeConverter/tests/System.ComponentModel.TypeConverter.Tests.csproj
+++ b/src/libraries/System.ComponentModel.TypeConverter/tests/System.ComponentModel.TypeConverter.Tests.csproj
@@ -74,6 +74,7 @@
     <Compile Include="Design\DesignerVerbTests.cs" />
     <Compile Include="Design\DesignerVerbCollectionTests.cs" />
     <Compile Include="Design\DesigntimeLicenseContextTests.cs" />
+    <Compile Include="Design\DesigntimeLicenseContextSerializerTests.cs" />
     <Compile Include="Design\HelpKeywordAttributeTests.cs" />
     <Compile Include="Design\Serialization\MemberRelationshipServiceTests.cs" />
     <Compile Include="Design\ServiceContainerTests.cs" />
diff --git a/src/libraries/System.ComponentModel.TypeConverter/tests/TrimmingTests/DesigntimeLicenseContextSerialization_Deserialize.cs b/src/libraries/System.ComponentModel.TypeConverter/tests/TrimmingTests/DesigntimeLicenseContextSerialization_Deserialize.cs
new file mode 100644
index 00000000000000..19cc5bdb81aa45
--- /dev/null
+++ b/src/libraries/System.ComponentModel.TypeConverter/tests/TrimmingTests/DesigntimeLicenseContextSerialization_Deserialize.cs
@@ -0,0 +1,39 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System;
+using System.ComponentModel.Design;
+using System.IO;
+using System.Reflection;
+
+/// <summary>
+/// Tests that the System.ComponentModel.TypeConverter.EnableUnsafeBinaryFormatterInDesigntimeLicenseContextSerialization
+/// property works as expected when used in a trimmed application.
+/// </summary>
+class Program
+{
+    static int Main(string[] args)
+    {
+        AppContext.SetSwitch("System.ComponentModel.TypeConverter.EnableUnsafeBinaryFormatterInDesigntimeLicenseContextSerialization", true);
+
+        /*
+        AFAICT, it is not straightforward to call System.ComponentModel.Design.DesigntimeLicenseContextSerializer.Deserialize because:
+            1. It is not public
+            2. RuntimeLicenseContext is internal. Even if we created this somehow, RuntimeLicenseContext._savedLicenseKeys is internal, so we'd have to initialize the HashTable in this test (which would defeat the purpose of having this test)
+            3. The public API that exercises the deserialize method requires the use of a *.lic file that needs to be embedded in some component. This would likely mean checking in some component with a license file and including it in this test. All the examples I've seen use Windows Forms components and add licensing to them. Not sure it is worth the effort here when we can test the same behavior with reflection.
+        */
+        using (MemoryStream stream = new MemoryStream(TrimmingTests.DesigntimeLicenseContextSerialization_Stream.ASampleStream))
+        {
+            Type runtimeLicenseContextType = Type.GetType("System.ComponentModel.Design.RuntimeLicenseContext, System.ComponentModel.TypeConverter");
+            object runtimeLicenseContext = Activator.CreateInstance(runtimeLicenseContextType, true);
+            FieldInfo _savedLicenseKeys = runtimeLicenseContextType.GetField("_savedLicenseKeys", BindingFlags.NonPublic | BindingFlags.Instance);
+
+            Type designtimeLicenseContextSerializer = Type.GetType("System.ComponentModel.Design.DesigntimeLicenseContextSerializer,System.ComponentModel.TypeConverter");
+            MethodInfo deserializeMethod = designtimeLicenseContextSerializer.GetMethod("Deserialize", BindingFlags.NonPublic | BindingFlags.Static);
+
+            deserializeMethod.Invoke(null, new object[] { stream, "key", runtimeLicenseContext });
+        }
+
+        return 100;
+    }
+}
diff --git a/src/libraries/System.ComponentModel.TypeConverter/tests/TrimmingTests/DesigntimeLicenseContextSerialization_Serialize.cs b/src/libraries/System.ComponentModel.TypeConverter/tests/TrimmingTests/DesigntimeLicenseContextSerialization_Serialize.cs
new file mode 100644
index 00000000000000..c0b08a116dc355
--- /dev/null
+++ b/src/libraries/System.ComponentModel.TypeConverter/tests/TrimmingTests/DesigntimeLicenseContextSerialization_Serialize.cs
@@ -0,0 +1,45 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.ComponentModel.Design;
+using System.IO;
+using System;
+
+/// <summary>
+/// Tests that the System.ComponentModel.TypeConverter.EnableUnsafeBinaryFormatterInDesigntimeLicenseContextSerialization
+/// property works as expected when used in a trimmed application.
+/// </summary>
+class Program
+{
+    static int Main(string[] args)
+    {
+        var context = new DesigntimeLicenseContext();
+        context.SetSavedLicenseKey(typeof(int), "key");
+        AppContext.SetSwitch("System.ComponentModel.TypeConverter.EnableUnsafeBinaryFormatterInDesigntimeLicenseContextSerialization", true);
+
+        using (MemoryStream stream = new MemoryStream())
+        {
+            long position = stream.Position;
+            System.ComponentModel.Design.DesigntimeLicenseContextSerializer.Serialize(stream, "key", context);
+            stream.Seek(position, SeekOrigin.Begin);
+
+            byte[] currentBuffer = stream.ToArray();
+            // Verify contents with saved stream
+            byte[] correctBytes = TrimmingTests.DesigntimeLicenseContextSerialization_Stream.ASampleStream;
+
+            if (currentBuffer.Length != correctBytes.Length)
+            {
+                return -1;
+            }
+            for (int i = 0; i < currentBuffer.Length; i++)
+            {
+                if (currentBuffer[i] != correctBytes[i])
+                {
+                    return -1;
+                }
+            }
+        }
+
+        return 100;
+    }
+}
diff --git a/src/libraries/System.ComponentModel.TypeConverter/tests/TrimmingTests/DesigntimeLicenseContextSerialization_Stream.cs b/src/libraries/System.ComponentModel.TypeConverter/tests/TrimmingTests/DesigntimeLicenseContextSerialization_Stream.cs
new file mode 100644
index 00000000000000..7395b2f94e6406
--- /dev/null
+++ b/src/libraries/System.ComponentModel.TypeConverter/tests/TrimmingTests/DesigntimeLicenseContextSerialization_Stream.cs
@@ -0,0 +1,15 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System;
+
+namespace TrimmingTests
+{
+    internal static class DesigntimeLicenseContextSerialization_Stream
+    {
+        public static byte[] ASampleStream { get; } = new byte[]
+        {
+0,1,0,0,0,255,255,255,255,1,0,0,0,0,0,0,0,16,1,0,0,0,2,0,0,0,6,2,0,0,0,3,107,101,121,9,3,0,0,0,4,3,0,0,0,28,83,121,115,116,101,109,46,67,111,108,108,101,99,116,105,111,110,115,46,72,97,115,104,116,97,98,108,101,7,0,0,0,10,76,111,97,100,70,97,99,116,111,114,7,86,101,114,115,105,111,110,8,67,111,109,112,97,114,101,114,16,72,97,115,104,67,111,100,101,80,114,111,118,105,100,101,114,8,72,97,115,104,83,105,122,101,4,75,101,121,115,6,86,97,108,117,101,115,0,0,3,3,0,5,5,11,8,28,83,121,115,116,101,109,46,67,111,108,108,101,99,116,105,111,110,115,46,73,67,111,109,112,97,114,101,114,36,83,121,115,116,101,109,46,67,111,108,108,101,99,116,105,111,110,115,46,73,72,97,115,104,67,111,100,101,80,114,111,118,105,100,101,114,8,236,81,56,63,1,0,0,0,10,10,3,0,0,0,9,4,0,0,0,9,5,0,0,0,16,4,0,0,0,1,0,0,0,6,6,0,0,0,103,83,121,115,116,101,109,46,73,110,116,51,50,44,32,83,121,115,116,101,109,46,80,114,105,118,97,116,101,46,67,111,114,101,76,105,98,44,32,86,101,114,115,105,111,110,61,54,46,48,46,48,46,48,44,32,67,117,108,116,117,114,101,61,110,101,117,116,114,97,108,44,32,80,117,98,108,105,99,75,101,121,84,111,107,101,110,61,55,99,101,99,56,53,100,55,98,101,97,55,55,57,56,101,16,5,0,0,0,1,0,0,0,9,2,0,0,0,11
+        };
+    }
+}
diff --git a/src/libraries/System.ComponentModel.TypeConverter/tests/TrimmingTests/System.ComponentModel.TypeConverter.TrimmingTests.proj b/src/libraries/System.ComponentModel.TypeConverter/tests/TrimmingTests/System.ComponentModel.TypeConverter.TrimmingTests.proj
index da4a46f2ae141a..f280b0c84f44db 100644
--- a/src/libraries/System.ComponentModel.TypeConverter/tests/TrimmingTests/System.ComponentModel.TypeConverter.TrimmingTests.proj
+++ b/src/libraries/System.ComponentModel.TypeConverter/tests/TrimmingTests/System.ComponentModel.TypeConverter.TrimmingTests.proj
@@ -1,5 +1,24 @@
 <Project DefaultTargets="Build">
   <Import Project="$([MSBuild]::GetPathOfFileAbove(Directory.Build.props))" />
 
+  <ItemGroup>
+    <TestConsoleAppSourceFiles Include="ComObjectTypeTest.cs" />
+    <TestConsoleAppSourceFiles Include="DesigntimeLicenseContextSerialization_Serialize.cs" TrimmerRootAssemblies="mscorlib">
+      <ExtraTrimmerArgs>--feature System.ComponentModel.TypeConverter.EnableUnsafeBinaryFormatterInDesigntimeLicenseContextSerialization true</ExtraTrimmerArgs>
+      <AdditionalSourceFiles>DesigntimeLicenseContextSerialization_Stream.cs</AdditionalSourceFiles>
+      <!-- Justification: BinaryFormatter is not available on wasm-->
+      <SkipOnTestRuntimes>browser-wasm</SkipOnTestRuntimes>
+    </TestConsoleAppSourceFiles>
+    <TestConsoleAppSourceFiles Include="DesigntimeLicenseContextSerialization_Deserialize.cs" TrimmerRootAssemblies="mscorlib">
+      <ExtraTrimmerArgs>--feature System.ComponentModel.TypeConverter.EnableUnsafeBinaryFormatterInDesigntimeLicenseContextSerialization true</ExtraTrimmerArgs>
+      <AdditionalSourceFiles>DesigntimeLicenseContextSerialization_Stream.cs</AdditionalSourceFiles>
+      <!-- Justification: BinaryFormatter is not available on wasm-->
+      <SkipOnTestRuntimes>browser-wasm</SkipOnTestRuntimes>
+    </TestConsoleAppSourceFiles>
+    <TestConsoleAppSourceFiles Include="InterfaceTypeTest.cs" />
+    <TestConsoleAppSourceFiles Include="TypeConverterIsReadOnly.cs" />
+    <TestConsoleAppSourceFiles Include="TypeConverterTest.cs" />
+  </ItemGroup>
+
   <Import Project="$([MSBuild]::GetPathOfFileAbove(Directory.Build.targets))" />
 </Project>