diff --git a/src/libraries/System.Linq/src/System/Linq/First.cs b/src/libraries/System.Linq/src/System/Linq/First.cs
index 95ada9a81cf4ea..8763d207c133de 100644
--- a/src/libraries/System.Linq/src/System/Linq/First.cs
+++ b/src/libraries/System.Linq/src/System/Linq/First.cs
@@ -89,11 +89,6 @@ private static TSource TryGetFirst<TSource>(this IEnumerable<TSource> source, Fu
                 ThrowHelper.ThrowArgumentNullException(ExceptionArgument.predicate);
             }
 
-            if (source is OrderedEnumerable<TSource> ordered)
-            {
-                return ordered.TryGetFirst(predicate, out found);
-            }
-
             foreach (TSource element in source)
             {
                 if (predicate(element))
diff --git a/src/libraries/System.Linq/src/System/Linq/OrderedEnumerable.cs b/src/libraries/System.Linq/src/System/Linq/OrderedEnumerable.cs
index da0ed0c7c47692..f28f7efa672de5 100644
--- a/src/libraries/System.Linq/src/System/Linq/OrderedEnumerable.cs
+++ b/src/libraries/System.Linq/src/System/Linq/OrderedEnumerable.cs
@@ -73,40 +73,6 @@ internal IEnumerator<TElement> GetEnumerator(int minIdx, int maxIdx)
         IOrderedEnumerable<TElement> IOrderedEnumerable<TElement>.CreateOrderedEnumerable<TKey>(Func<TElement, TKey> keySelector, IComparer<TKey>? comparer, bool descending) =>
             new OrderedEnumerable<TElement, TKey>(_source, keySelector, comparer, @descending, this);
 
-        [return: MaybeNull]
-        public TElement TryGetFirst(Func<TElement, bool> predicate, out bool found)
-        {
-            CachingComparer<TElement> comparer = GetComparer();
-            using (IEnumerator<TElement> e = _source.GetEnumerator())
-            {
-                TElement value;
-                do
-                {
-                    if (!e.MoveNext())
-                    {
-                        found = false;
-                        return default!;
-                    }
-
-                    value = e.Current;
-                }
-                while (!predicate(value));
-
-                comparer.SetElement(value);
-                while (e.MoveNext())
-                {
-                    TElement x = e.Current;
-                    if (predicate(x) && comparer.Compare(x, true) < 0)
-                    {
-                        value = x;
-                    }
-                }
-
-                found = true;
-                return value;
-            }
-        }
-
         [return: MaybeNull]
         public TElement TryGetLast(Func<TElement, bool> predicate, out bool found)
         {
diff --git a/src/libraries/System.Linq/tests/OrderByTests.cs b/src/libraries/System.Linq/tests/OrderByTests.cs
index 8c99b5668c763f..627becd98800b5 100644
--- a/src/libraries/System.Linq/tests/OrderByTests.cs
+++ b/src/libraries/System.Linq/tests/OrderByTests.cs
@@ -291,6 +291,38 @@ public void FirstOnEmptyOrderedThrows()
             Assert.Throws<InvalidOperationException>(() => Enumerable.Empty<int>().OrderBy(i => i).First());
         }
 
+        [Fact]
+        public void FirstWithPredicateOnOrdered()
+        {
+            IEnumerable<int> orderBy = Enumerable.Range(0, 10).Shuffle().OrderBy(i => i);
+            IEnumerable<int> orderByDescending = Enumerable.Range(0, 10).Shuffle().OrderByDescending(i => i);
+            int counter;
+
+            counter = 0;
+            Assert.Equal(0, orderBy.First(i => { counter++; return true; }));
+            Assert.Equal(1, counter);
+
+            counter = 0;
+            Assert.Equal(9, orderBy.First(i => { counter++; return i == 9; }));
+            Assert.Equal(10, counter);
+
+            counter = 0;
+            Assert.Throws<InvalidOperationException>(() => orderBy.First(i => { counter++; return false; }));
+            Assert.Equal(10, counter);
+
+            counter = 0;
+            Assert.Equal(9, orderByDescending.First(i => { counter++; return true; }));
+            Assert.Equal(1, counter);
+
+            counter = 0;
+            Assert.Equal(0, orderByDescending.First(i => { counter++; return i == 0; }));
+            Assert.Equal(10, counter);
+
+            counter = 0;
+            Assert.Throws<InvalidOperationException>(() => orderByDescending.First(i => { counter++; return false; }));
+            Assert.Equal(10, counter);
+        }
+
         [Fact]
         public void FirstOrDefaultOnOrdered()
         {
@@ -300,6 +332,38 @@ public void FirstOrDefaultOnOrdered()
             Assert.Equal(0, Enumerable.Empty<int>().OrderBy(i => i).FirstOrDefault());
         }
 
+        [Fact]
+        public void FirstOrDefaultWithPredicateOnOrdered()
+        {
+            IEnumerable<int> orderBy = Enumerable.Range(0, 10).Shuffle().OrderBy(i => i);
+            IEnumerable<int> orderByDescending = Enumerable.Range(0, 10).Shuffle().OrderByDescending(i => i);
+            int counter;
+
+            counter = 0;
+            Assert.Equal(0, orderBy.FirstOrDefault(i => { counter++; return true; }));
+            Assert.Equal(1, counter);
+
+            counter = 0;
+            Assert.Equal(9, orderBy.FirstOrDefault(i => { counter++; return i == 9; }));
+            Assert.Equal(10, counter);
+
+            counter = 0;
+            Assert.Equal(0, orderBy.FirstOrDefault(i => { counter++; return false; }));
+            Assert.Equal(10, counter);
+
+            counter = 0;
+            Assert.Equal(9, orderByDescending.FirstOrDefault(i => { counter++; return true; }));
+            Assert.Equal(1, counter);
+
+            counter = 0;
+            Assert.Equal(0, orderByDescending.FirstOrDefault(i => { counter++; return i == 0; }));
+            Assert.Equal(10, counter);
+
+            counter = 0;
+            Assert.Equal(0, orderByDescending.FirstOrDefault(i => { counter++; return false; }));
+            Assert.Equal(10, counter);
+        }
+
         [Fact]
         public void LastOnOrdered()
         {