diff --git a/lucene/CHANGES.txt b/lucene/CHANGES.txt
index dac9b15853af..fba7e1144c28 100644
--- a/lucene/CHANGES.txt
+++ b/lucene/CHANGES.txt
@@ -311,9 +311,6 @@ API Changes
 * GITHUB#13568, GITHUB#13750: Add DrillSideways#search method that supports any CollectorManagers for drill-sideways dimensions
   or drill-down. (Egor Potemkin)
 
-* GITHUB#13735: Add CollectorManager#forSequentialExecution to make CollectorManager creation more convenient
-  for users of the deprecated IndexSearcher#search(Query, Collector). (Greg Miller)
-
 New Features
 ---------------------
 
diff --git a/lucene/core/src/java/org/apache/lucene/search/CollectorManager.java b/lucene/core/src/java/org/apache/lucene/search/CollectorManager.java
index c33712b13218..3c87a94e36d9 100644
--- a/lucene/core/src/java/org/apache/lucene/search/CollectorManager.java
+++ b/lucene/core/src/java/org/apache/lucene/search/CollectorManager.java
@@ -18,8 +18,6 @@
 
 import java.io.IOException;
 import java.util.Collection;
-import java.util.concurrent.Executor;
-import org.apache.lucene.index.IndexReader;
 import org.apache.lucene.index.LeafReaderContext;
 
 /**
@@ -55,36 +53,4 @@ public interface CollectorManager<C extends Collector, T> {
    * called after collection is finished on all provided collectors.
    */
   T reduce(Collection<C> collectors) throws IOException;
-
-  /**
-   * Wrap a provided {@link Collector} with a thin {@code CollectorManager} wrapper for use with
-   * {@link IndexSearcher#search(Query, CollectorManager)} when doing single-threaded searching. The
-   * wrapping {@code CollectorManager} provides no {@link CollectorManager#reduce(Collection)}
-   * implementation, so the wrapped {@code Collector} needs to do all relevant work while
-   * collecting.
-   *
-   * <p>Note: This is only safe to use when {@code IndexSearcher} is created with no executor (see:
-   * {@link IndexSearcher#IndexSearcher(IndexReader, Executor)}).
-   */
-  static <C extends Collector> CollectorManager<C, ?> forSequentialExecution(C in) {
-    return new CollectorManager<C, Void>() {
-      private boolean newCollectorInvoked;
-
-      @Override
-      public C newCollector() {
-        if (newCollectorInvoked) {
-          throw new IllegalStateException(
-              "newCollector should be invoked at most once. Ensure your IndexSearcher has been created without an Executor.");
-        }
-        newCollectorInvoked = true;
-        return in;
-      }
-
-      @Override
-      public Void reduce(Collection<C> collectors) {
-        assert collectors.size() == 1 : "collectors should contain exactly one collector instance";
-        return null;
-      }
-    };
-  }
 }
diff --git a/lucene/monitor/src/java/org/apache/lucene/monitor/CollectingMatcher.java b/lucene/monitor/src/java/org/apache/lucene/monitor/CollectingMatcher.java
index 6175fec5ca33..c434672fd68d 100644
--- a/lucene/monitor/src/java/org/apache/lucene/monitor/CollectingMatcher.java
+++ b/lucene/monitor/src/java/org/apache/lucene/monitor/CollectingMatcher.java
@@ -18,6 +18,7 @@
 package org.apache.lucene.monitor;
 
 import java.io.IOException;
+import java.util.Collection;
 import java.util.Map;
 import org.apache.lucene.search.CollectorManager;
 import org.apache.lucene.search.IndexSearcher;
@@ -38,9 +39,29 @@ abstract class CollectingMatcher<T extends QueryMatch> extends CandidateMatcher<
   @Override
   public void matchQuery(final String queryId, Query matchQuery, Map<String, String> metadata)
       throws IOException {
+    MatchCollector matchCollector = new MatchCollector(queryId, scoreMode);
     searcher.search(
         matchQuery,
-        CollectorManager.forSequentialExecution(new MatchCollector(queryId, scoreMode)));
+        new CollectorManager<MatchCollector, Void>() {
+          boolean newCollectorInvoked = false;
+
+          @Override
+          public MatchCollector newCollector() {
+            if (newCollectorInvoked) {
+              throw new IllegalStateException(
+                  "newCollector should be invoked at most once. Ensure your IndexSearcher has been created without an Executor.");
+            }
+            newCollectorInvoked = true;
+            return matchCollector;
+          }
+
+          @Override
+          public Void reduce(Collection<MatchCollector> collectors) {
+            assert collectors.size() == 1
+                : "collectors should contain exactly one collector instance";
+            return null;
+          }
+        });
   }
 
   /**