--- a/accessible/windows/msaa/Platform.cpp
+++ b/accessible/windows/msaa/Platform.cpp
@@ -275,16 +275,18 @@ GetInstantiatorExecutable(const DWORD aP
   if (NS_FAILED(rv)) {
     return false;
   }
 
   file.forget(aOutClientExe);
   return NS_SUCCEEDED(rv);
 }
 
+#if defined(MOZ_TELEMETRY_REPORTING) || defined(MOZ_CRASHREPORTER)
+
 /**
  * Appends version information in the format "|a.b.c.d".
  * If there is no version information, we append nothing.
  */
 static void
 AppendVersionInfo(nsIFile* aClientExe, nsAString& aStrToAppend)
 {
   MOZ_ASSERT(!NS_IsMainThread());
@@ -328,75 +330,92 @@ AppendVersionInfo(nsIFile* aClientExe, n
   aStrToAppend.AppendInt(minor);
   aStrToAppend.Append(dot);
   aStrToAppend.AppendInt(patch);
   aStrToAppend.Append(dot);
   aStrToAppend.AppendInt(build);
 }
 
 static void
-AccumulateInstantiatorTelemetry(nsIFile* aClientExe, const nsAString& aValue)
+AccumulateInstantiatorTelemetry(const nsAString& aValue)
 {
   MOZ_ASSERT(NS_IsMainThread());
 
   if (!aValue.IsEmpty()) {
 #if defined(MOZ_TELEMETRY_REPORTING)
     Telemetry::ScalarSet(Telemetry::ScalarID::A11Y_INSTANTIATORS,
                          aValue);
 #endif // defined(MOZ_TELEMETRY_REPORTING)
+#if defined(MOZ_CRASHREPORTER)
     CrashReporter::
       AnnotateCrashReport(NS_LITERAL_CSTRING("AccessibilityClient"),
                           NS_ConvertUTF16toUTF8(aValue));
+#endif // defined(MOZ_CRASHREPORTER)
   }
 }
 
 static void
 GatherInstantiatorTelemetry(nsIFile* aClientExe)
 {
   MOZ_ASSERT(!NS_IsMainThread());
 
   nsString value;
   nsresult rv = aClientExe->GetLeafName(value);
   if (NS_SUCCEEDED(rv)) {
     AppendVersionInfo(aClientExe, value);
   }
 
-  nsCOMPtr<nsIFile> ref(aClientExe);
   nsCOMPtr<nsIRunnable> runnable(
     NS_NewRunnableFunction("a11y::AccumulateInstantiatorTelemetry",
-                           [ref, value]() -> void {
-                             AccumulateInstantiatorTelemetry(ref, value);
+                           [value]() -> void {
+                             AccumulateInstantiatorTelemetry(value);
                            }));
 
   // Now that we've (possibly) obtained version info, send the resulting
   // string back to the main thread to accumulate in telemetry.
   NS_DispatchToMainThread(runnable);
 }
 
+#endif // defined(MOZ_TELEMETRY_REPORTING) || defined(MOZ_CRASHREPORTER)
+
 void
 a11y::SetInstantiator(const uint32_t aPid)
 {
   nsCOMPtr<nsIFile> clientExe;
   if (!GetInstantiatorExecutable(aPid, getter_AddRefs(clientExe))) {
-#if defined(MOZ_TELEMETRY_REPORTING)
-    AccumulateInstantiatorTelemetry(nullptr, NS_LITERAL_STRING("(Failed to retrieve client image name)"));
-#endif // defined(MOZ_TELEMETRY_REPORTING)
+#if defined(MOZ_TELEMETRY_REPORTING) || defined(MOZ_CRASHREPORTER)
+    AccumulateInstantiatorTelemetry(NS_LITERAL_STRING("(Failed to retrieve client image name)"));
+#endif // defined(MOZ_TELEMETRY_REPORTING) || defined(MOZ_CRASHREPORTER)
     return;
   }
 
+  // Only record the instantiator if it is the first instantiator, or if it does
+  // not match the previous one. Some blocked clients are repeatedly requesting
+  // a11y over and over so we don't want to be spawning countless telemetry
+  // threads.
+  if (gInstantiator) {
+    bool equal;
+    nsresult rv = gInstantiator->Equals(clientExe, &equal);
+    if (NS_SUCCEEDED(rv) && equal) {
+      return;
+    }
+  }
+
   gInstantiator = clientExe;
 
+#if defined(MOZ_TELEMETRY_REPORTING) || defined(MOZ_CRASHREPORTER)
   nsCOMPtr<nsIRunnable> runnable(
     NS_NewRunnableFunction("a11y::GatherInstantiatorTelemetry",
                            [clientExe]() -> void {
                              GatherInstantiatorTelemetry(clientExe);
                            }));
 
   nsCOMPtr<nsIThread> telemetryThread;
-  NS_NewThread(getter_AddRefs(telemetryThread), runnable);
+  NS_NewNamedThread("a11y telemetry", getter_AddRefs(telemetryThread), runnable);
+#endif // defined(MOZ_TELEMETRY_REPORTING) || defined(MOZ_CRASHREPORTER)
 }
 
 bool
 a11y::GetInstantiator(nsIFile** aOutInstantiator)
 {
   if (!gInstantiator) {
     return false;
   }