Try a solution not changing public API surface and using NSLogStream …

…with a decoder

src/libraries/System.Console/src/System.Console.csproj

@@ -4,11 +4,6 @@
     <TargetFrameworks>$(NetCoreAppCurrent)-windows;$(NetCoreAppCurrent)-Unix;$(NetCoreAppCurrent)-Android;$(NetCoreAppCurrent)-iOS;$(NetCoreAppCurrent)-tvOS;$(NetCoreAppCurrent)-Browser</TargetFrameworks>
     <Nullable>enable</Nullable>
   </PropertyGroup>
-  <PropertyGroup>
-    <DefineConstants Condition="'$(TargetsMacCatalyst)' == 'true'">$(DefineConstants);TARGET_MACCATALYST</DefineConstants>
-    <DefineConstants Condition="'$(TargetsiOS)' == 'true'">$(DefineConstants);TARGET_IOS</DefineConstants>
-    <DefineConstants Condition="'$(TargetstvOS)' == 'true'">$(DefineConstants);TARGET_TVOS</DefineConstants>
-  </PropertyGroup>
   <ItemGroup>
     <Compile Include="System\Console.cs" />
     <Compile Include="System\ConsoleCancelEventArgs.cs" />
@@ -30,7 +25,6 @@
              Link="Common\Interop\Unix\Interop.Log.cs" />
     <Compile Include="$(CommonPath)Interop\Unix\Interop.Libraries.cs"
              Link="Common\Interop\Unix\Interop.Libraries.cs" />
-    <Compile Include="System\IO\StreamWriter.iOS.cs" />
   </ItemGroup>
   <!-- Android -->
   <ItemGroup Condition="'$(TargetsAndroid)' == 'true'">

src/libraries/System.Console/src/System/Console.cs

@@ -236,11 +236,7 @@ private static TextWriter CreateOutputWriter(Stream outputStream)
         {
             return TextWriter.Synchronized(outputStream == Stream.Null ?
                 StreamWriter.Null :
-#if TARGET_IOS || TARGET_TVOS || TARGET_MACCATALYST
-                new IOSStreamWriter(
-#else
                 new StreamWriter(
-#endif
                     stream: outputStream,
                     encoding: OutputEncoding.RemovePreamble(), // This ensures no prefix is written to the stream.
                     bufferSize: WriteBufferSize,

src/libraries/System.Console/src/System/ConsolePal.iOS.cs

@@ -1,23 +1,89 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using System.Diagnostics;
 using System.IO;
+using System.Runtime.InteropServices;
 using System.Text;
 
 namespace System
 {
     internal sealed class NSLogStream : ConsoleStream
     {
-        public NSLogStream() : base(FileAccess.Write) {}
+        private readonly StringBuilder _buffer = new StringBuilder();
+        private Decoder _decoder;
+
+        public NSLogStream() : base(FileAccess.Write)
+        {
+            _decoder = Encoding.Unicode.GetDecoder();
+        }
 
         public override int Read(Span<byte> buffer) => throw Error.GetReadNotSupported();
 
         public override unsafe void Write(ReadOnlySpan<byte> buffer)
         {
-            fixed (byte* ptr = buffer)
+            int charCount = _decoder.GetCharCount(buffer, false);
+            Span<char> charSpan = new char[charCount];
+            int count = _decoder.GetChars(buffer, charSpan, false);
+            if (count > 0)
+            {
+                WriteOrCache(_buffer, charSpan);
+            }
+        }
+
+        private static unsafe void WriteOrCache(StringBuilder cache, Span<char> charBuffer)
+        {
+            int lineStartIndex = 0;
+            for (int i = 0; i < charBuffer.Length; i++)
+            {
+                if (charBuffer[i] == '\n')
+                {
+                    Span<char> lineSpan = charBuffer.Slice(lineStartIndex, i - lineStartIndex);
+                    if (cache.Length > 0)
+                    {
+                        printer(cache.Append(lineSpan).ToString());
+                        cache.Clear();
+                    }
+                    else
+                    {
+                        printer(lineSpan.ToString());
+                    }
+
+                    lineStartIndex = i + 1;
+                }
+            }
+
+            if (lineStartIndex < charBuffer.Length)
+            {
+                // no newlines found, add the entire buffer to the cache
+                cache.Append(charBuffer.Slice(lineStartIndex, charBuffer.Length - lineStartIndex));
+            }
+
+            static void printer(string line)
+            {
+                fixed (char* ptr = line)
+                {
+                    Interop.Sys.Log((byte*)ptr, line.Length * 2);
+                }
+            }
+        }
+
+        protected override void Dispose(bool disposing)
+        {
+            if (_buffer.Length > 0)
             {
-                Interop.Sys.Log(ptr, buffer.Length);
+                var line = _buffer.ToString();
+                _buffer.Clear();
+                unsafe
+                {
+                    fixed (char* ptr = line)
+                    {
+                        Interop.Sys.Log((byte*)ptr, line.Length * 2);
+                    }
+                }
             }
+
+            base.Dispose(disposing);
         }
     }