diff --git a/level_zero/core/source/cmdlist/cmdlist_hw_immediate.inl b/level_zero/core/source/cmdlist/cmdlist_hw_immediate.inl
index a717b7c103..8b66e14f48 100644
--- a/level_zero/core/source/cmdlist/cmdlist_hw_immediate.inl
+++ b/level_zero/core/source/cmdlist/cmdlist_hw_immediate.inl
@@ -1037,16 +1037,22 @@ ze_result_t CommandListCoreFamilyImmediate<gfxCoreFamily>::appendWaitExternalSem
     auto driverHandleImp = static_cast<DriverHandleImp *>(this->device->getDriverHandle());
 
     for (uint32_t i = 0; i < numExternalSemaphores; i++) {
+        std::lock_guard<std::mutex> lock(driverHandleImp->externalSemaphoreController->semControllerMutex);
+
         ze_event_handle_t proxyWaitEvent = nullptr;
-        ret = driverHandleImp->externalSemaphoreController->allocateProxyEvent(hSemaphores[i], this->device->toHandle(), this->hContext, params[i].value, &proxyWaitEvent, ExternalSemaphoreController::SemaphoreOperation::Wait);
+        ret = driverHandleImp->externalSemaphoreController->allocateProxyEvent(this->device->toHandle(), this->hContext, &proxyWaitEvent);
         if (ret != ZE_RESULT_SUCCESS) {
             return ret;
         }
 
         ret = this->appendWaitOnEvents(1u, &proxyWaitEvent, nullptr, false, false, false, false, false, false);
         if (ret != ZE_RESULT_SUCCESS) {
+            auto event = Event::fromHandle(proxyWaitEvent);
+            event->destroy();
             return ret;
         }
+
+        driverHandleImp->externalSemaphoreController->proxyEvents.push_back(std::make_tuple(Event::fromHandle(proxyWaitEvent), static_cast<ExternalSemaphore *>(ExternalSemaphore::fromHandle(hSemaphores[i])), params[i].value, ExternalSemaphoreController::SemaphoreOperation::Wait));
     }
 
     driverHandleImp->externalSemaphoreController->semControllerCv.notify_one();
@@ -1082,16 +1088,22 @@ ze_result_t CommandListCoreFamilyImmediate<gfxCoreFamily>::appendSignalExternalS
     auto driverHandleImp = static_cast<DriverHandleImp *>(this->device->getDriverHandle());
 
     for (size_t i = 0; i < numExternalSemaphores; i++) {
+        std::lock_guard<std::mutex> lock(driverHandleImp->externalSemaphoreController->semControllerMutex);
+
         ze_event_handle_t proxySignalEvent = nullptr;
-        ret = driverHandleImp->externalSemaphoreController->allocateProxyEvent(hSemaphores[i], this->device->toHandle(), this->hContext, params[i].value, &proxySignalEvent, ExternalSemaphoreController::SemaphoreOperation::Signal);
+        ret = driverHandleImp->externalSemaphoreController->allocateProxyEvent(this->device->toHandle(), this->hContext, &proxySignalEvent);
         if (ret != ZE_RESULT_SUCCESS) {
             return ret;
         }
 
         ret = this->appendSignalEvent(proxySignalEvent, false);
         if (ret != ZE_RESULT_SUCCESS) {
+            auto event = Event::fromHandle(proxySignalEvent);
+            event->destroy();
             return ret;
         }
+
+        driverHandleImp->externalSemaphoreController->proxyEvents.push_back(std::make_tuple(Event::fromHandle(proxySignalEvent), static_cast<ExternalSemaphore *>(ExternalSemaphore::fromHandle(hSemaphores[i])), params[i].value, ExternalSemaphoreController::SemaphoreOperation::Signal));
     }
 
     driverHandleImp->externalSemaphoreController->semControllerCv.notify_one();
diff --git a/level_zero/core/source/semaphore/external_semaphore_imp.cpp b/level_zero/core/source/semaphore/external_semaphore_imp.cpp
index 51f26cb420..d876e7d035 100644
--- a/level_zero/core/source/semaphore/external_semaphore_imp.cpp
+++ b/level_zero/core/source/semaphore/external_semaphore_imp.cpp
@@ -118,9 +118,7 @@ std::unique_ptr<ExternalSemaphoreController> ExternalSemaphoreController::create
     return std::make_unique<ExternalSemaphoreController>();
 }
 
-ze_result_t ExternalSemaphoreController::allocateProxyEvent(ze_external_semaphore_ext_handle_t hExtSemaphore, ze_device_handle_t hDevice, ze_context_handle_t hContext, uint64_t fenceValue, ze_event_handle_t *phEvent, ExternalSemaphoreController::SemaphoreOperation operation) {
-    std::lock_guard<std::mutex> lock(this->semControllerMutex);
-
+ze_result_t ExternalSemaphoreController::allocateProxyEvent(ze_device_handle_t hDevice, ze_context_handle_t hContext, ze_event_handle_t *phEvent) {
     if (this->eventPoolsMap.find(hDevice) == this->eventPoolsMap.end()) {
         this->eventPoolsMap[hDevice] = std::vector<EventPool *>();
         this->eventsCreatedFromLatestPoolMap[hDevice] = 0u;
@@ -151,8 +149,6 @@ ze_result_t ExternalSemaphoreController::allocateProxyEvent(ze_external_semaphor
     ze_event_handle_t hEvent{};
     pool->createEvent(&desc, &hEvent);
 
-    this->proxyEvents.push_back(std::make_tuple(Event::fromHandle(hEvent), static_cast<ExternalSemaphore *>(ExternalSemaphore::fromHandle(hExtSemaphore)), fenceValue, operation));
-
     *phEvent = hEvent;
 
     return ZE_RESULT_SUCCESS;
diff --git a/level_zero/core/source/semaphore/external_semaphore_imp.h b/level_zero/core/source/semaphore/external_semaphore_imp.h
index 6b5401d660..8607ecccf2 100644
--- a/level_zero/core/source/semaphore/external_semaphore_imp.h
+++ b/level_zero/core/source/semaphore/external_semaphore_imp.h
@@ -85,7 +85,7 @@ class ExternalSemaphoreController : NEO::NonCopyableAndNonMovableClass {
         }
     }
 
-    ze_result_t allocateProxyEvent(ze_external_semaphore_ext_handle_t hExtSemaphore, ze_device_handle_t hDevice, ze_context_handle_t hContext, uint64_t fenceValue, ze_event_handle_t *phEvent, SemaphoreOperation operation);
+    ze_result_t allocateProxyEvent(ze_device_handle_t hDevice, ze_context_handle_t hContext, ze_event_handle_t *phEvent);
     void processProxyEvents();
 
     std::mutex semControllerMutex;
diff --git a/level_zero/core/test/unit_tests/mt_tests/semaphore/windows/test_mt_semaphore_windows.cpp b/level_zero/core/test/unit_tests/mt_tests/semaphore/windows/test_mt_semaphore_windows.cpp
index f246da0710..e72687c36a 100644
--- a/level_zero/core/test/unit_tests/mt_tests/semaphore/windows/test_mt_semaphore_windows.cpp
+++ b/level_zero/core/test/unit_tests/mt_tests/semaphore/windows/test_mt_semaphore_windows.cpp
@@ -296,7 +296,7 @@ struct MockCommandListImmediateExtSem : public WhiteBox<::L0::CommandListCoreFam
     bool failingSignalEvent = false;
 };
 
-HWTEST2_F(WddmExternalSemaphoreMTTest, DISABLED_givenInternalProxyEventFailsToAppendWhenAppendWaitExternalSemaphoresExpIsCalledThenErrorIsReturned, MatchAny) {
+HWTEST2_F(WddmExternalSemaphoreMTTest, givenInternalProxyEventFailsToAppendWhenAppendWaitExternalSemaphoresExpIsCalledThenErrorIsReturned, MatchAny) {
     ze_external_semaphore_ext_desc_t desc = {};
     ze_external_semaphore_ext_handle_t hSemaphore;
     HANDLE extSemaphoreHandle = 0;
diff --git a/level_zero/core/test/unit_tests/sources/semaphore/test_semaphore.cpp b/level_zero/core/test/unit_tests/sources/semaphore/test_semaphore.cpp
index ca7f65dc50..5b568589b5 100644
--- a/level_zero/core/test/unit_tests/sources/semaphore/test_semaphore.cpp
+++ b/level_zero/core/test/unit_tests/sources/semaphore/test_semaphore.cpp
@@ -450,12 +450,14 @@ HWTEST2_F(ExternalSemaphoreTest, givenExternalSemaphoreControllerWhenAllocatePro
     ze_event_handle_t proxyEvent1 = {};
     ze_event_handle_t proxyEvent2 = {};
 
-    ze_result_t result = driverHandleImp->externalSemaphoreController->allocateProxyEvent(externalSemaphore1->toHandle(), l0Device->toHandle(), context->toHandle(), 1u, &proxyEvent1, ExternalSemaphoreController::SemaphoreOperation::Wait);
+    ze_result_t result = driverHandleImp->externalSemaphoreController->allocateProxyEvent(l0Device->toHandle(), context->toHandle(), &proxyEvent1);
     EXPECT_EQ(result, ZE_RESULT_SUCCESS);
+    driverHandleImp->externalSemaphoreController->proxyEvents.push_back(std::make_tuple(Event::fromHandle(proxyEvent1), static_cast<ExternalSemaphore *>(ExternalSemaphore::fromHandle(externalSemaphore1->toHandle())), 1u, ExternalSemaphoreController::SemaphoreOperation::Wait));
     EXPECT_EQ(driverHandleImp->externalSemaphoreController->proxyEvents.size(), 1u);
 
-    result = driverHandleImp->externalSemaphoreController->allocateProxyEvent(externalSemaphore1->toHandle(), l0Device->toHandle(), context->toHandle(), 1u, &proxyEvent2, ExternalSemaphoreController::SemaphoreOperation::Wait);
+    result = driverHandleImp->externalSemaphoreController->allocateProxyEvent(l0Device->toHandle(), context->toHandle(), &proxyEvent2);
     EXPECT_EQ(result, ZE_RESULT_SUCCESS);
+    driverHandleImp->externalSemaphoreController->proxyEvents.push_back(std::make_tuple(Event::fromHandle(proxyEvent2), static_cast<ExternalSemaphore *>(ExternalSemaphore::fromHandle(externalSemaphore2->toHandle())), 1u, ExternalSemaphoreController::SemaphoreOperation::Wait));
     EXPECT_EQ(driverHandleImp->externalSemaphoreController->proxyEvents.size(), 2u);
 }
 
@@ -475,14 +477,16 @@ HWTEST2_F(ExternalSemaphoreTest, givenMaxEventsInPoolCreatedWhenAllocateProxyEve
     ze_event_handle_t proxyEvent1 = {};
     ze_event_handle_t proxyEvent2 = {};
 
-    ze_result_t result = driverHandleImp->externalSemaphoreController->allocateProxyEvent(externalSemaphore1->toHandle(), l0Device->toHandle(), context->toHandle(), 1u, &proxyEvent1, ExternalSemaphoreController::SemaphoreOperation::Wait);
+    ze_result_t result = driverHandleImp->externalSemaphoreController->allocateProxyEvent(l0Device->toHandle(), context->toHandle(), &proxyEvent1);
     EXPECT_EQ(result, ZE_RESULT_SUCCESS);
+    driverHandleImp->externalSemaphoreController->proxyEvents.push_back(std::make_tuple(Event::fromHandle(proxyEvent1), static_cast<ExternalSemaphore *>(ExternalSemaphore::fromHandle(externalSemaphore1->toHandle())), 1u, ExternalSemaphoreController::SemaphoreOperation::Wait));
     EXPECT_EQ(driverHandleImp->externalSemaphoreController->proxyEvents.size(), 1u);
     EXPECT_EQ(driverHandleImp->externalSemaphoreController->eventPoolsMap[l0Device->toHandle()].size(), 1u);
 
     driverHandleImp->externalSemaphoreController->eventsCreatedFromLatestPoolMap[l0Device->toHandle()] = 20;
-    result = driverHandleImp->externalSemaphoreController->allocateProxyEvent(externalSemaphore1->toHandle(), l0Device->toHandle(), context->toHandle(), 1u, &proxyEvent2, ExternalSemaphoreController::SemaphoreOperation::Wait);
+    result = driverHandleImp->externalSemaphoreController->allocateProxyEvent(l0Device->toHandle(), context->toHandle(), &proxyEvent2);
     EXPECT_EQ(result, ZE_RESULT_SUCCESS);
+    driverHandleImp->externalSemaphoreController->proxyEvents.push_back(std::make_tuple(Event::fromHandle(proxyEvent2), static_cast<ExternalSemaphore *>(ExternalSemaphore::fromHandle(externalSemaphore2->toHandle())), 1u, ExternalSemaphoreController::SemaphoreOperation::Wait));
     EXPECT_EQ(driverHandleImp->externalSemaphoreController->proxyEvents.size(), 2u);
     EXPECT_EQ(driverHandleImp->externalSemaphoreController->eventPoolsMap[l0Device->toHandle()].size(), 2u);
 }