diff --git a/src/Util/BusinessRulesProcessor.php b/src/Util/BusinessRulesProcessor.php
index e09b587..6bc0cb4 100644
--- a/src/Util/BusinessRulesProcessor.php
+++ b/src/Util/BusinessRulesProcessor.php
@@ -670,10 +670,7 @@ class BusinessRulesProcessor {
       foreach ($variablesSet->getVariables() as $variable) {
         $varObject = Variable::load($variable->getId());
         if ($varObject instanceof Variable) {
-          // Do note evaluate the same variable twice to avid overload.
-          if (!array_key_exists($variable->getId(), $this->evaluatedVariables)) {
-            $this->evaluateVariable($varObject, $event);
-          }
+          $this->evaluateVariable($varObject, $event);
         }
       }
     }
@@ -698,7 +695,7 @@ class BusinessRulesProcessor {
   public function evaluateVariable(Variable $variable, BusinessRulesEvent $event) {
 
     // Do note evaluate the same variable twice to avid overload.
-    if (array_key_exists($variable->id(), $this->evaluatedVariables)) {
+    if ($this->isVariableAlreadyEvaluated($variable->id(), $event)) {
       return NULL;
     }
 
@@ -711,7 +708,7 @@ class BusinessRulesProcessor {
     $value = $variable->evaluate($event);
 
     if ($value instanceof VariableObject) {
-      $this->evaluatedVariables[$variable->id()] = $variable->id();
+      $this->setVariableAlreadyEvaluated($value->getId(), $event);
       $eventVariables->append($value);
       $this->debugArray['variables'][$this->ruleBeingExecuted->id()][$variable->id()] = $value;
 
@@ -720,7 +717,7 @@ class BusinessRulesProcessor {
     elseif ($value instanceof VariablesSet) {
       if ($value->count()) {
         foreach ($value->getVariables() as $item) {
-          $this->evaluatedVariables[$item->getId()] = $item->getId();
+          $this->setVariableAlreadyEvaluated($item->getId(), $event);
           $eventVariables->append($item);
           $this->debugArray['variables'][$this->ruleBeingExecuted->id()][$item->getId()] = $item;
         }
@@ -765,6 +762,53 @@ class BusinessRulesProcessor {
     return !empty($business_rule_entity);
   }
 
+  /**
+   * Checks whether a given variable has already been evaluated.
+   *
+   * @param string $id
+   *   The variable ID.
+   * @param \Drupal\business_rules\Events\BusinessRulesEvent $event
+   *   The event.
+   *
+   * @return bool
+   *   TRUE if variable has already been evaluated, FALSE otherwise.
+   */
+  protected function isVariableAlreadyEvaluated($id, BusinessRulesEvent $event) {
+    return array_key_exists($this->buildEvaluatedVariableCacheId($id, $event), $this->evaluatedVariables);
+  }
+
+  /**
+   * Sets given variable as already evaluated.
+   *
+   * @param string $id
+   *   The variable ID.
+   * @param \Drupal\business_rules\Events\BusinessRulesEvent $event
+   *   The event.
+   */
+  protected function setVariableAlreadyEvaluated($id, BusinessRulesEvent $event) {
+    $this->evaluatedVariables[$this->buildEvaluatedVariableCacheId($id, $event)] = TRUE;
+  }
+
+  /**
+   * Builds evaluated variable cache ID.
+   *
+   * Cache ID is based on the event loop control argument which distinctly
+   * defines the event, especially when the same event is fired multiple times
+   * within the same request (but with different entities), e.g. during a
+   * migration.
+   *
+   * @param string $id
+   *   The variable ID.
+   * @param \Drupal\business_rules\Events\BusinessRulesEvent $event
+   *   The event.
+   *
+   * @return string
+   *   Evaluated variable cache ID.
+   */
+  protected function buildEvaluatedVariableCacheId($id, BusinessRulesEvent $event) {
+    return $event->getArgument('loop_control') . ':' . $id;
+  }
+
   /**
    * Destructor.
    */
diff --git a/tests/src/Unit/BusinessRulesProcessorTest.php b/tests/src/Unit/BusinessRulesProcessorTest.php
new file mode 100644
index 0000000..04bea0b
--- /dev/null
+++ b/tests/src/Unit/BusinessRulesProcessorTest.php
@@ -0,0 +1,186 @@
+<?php
+
+namespace Drupal\Tests\business_rules\Unit;
+
+use Drupal\business_rules\Entity\BusinessRule;
+use Drupal\business_rules\Entity\Variable;
+use Drupal\business_rules\Events\BusinessRulesEvent;
+use Drupal\business_rules\Plugin\BusinessRulesActionManager;
+use Drupal\business_rules\Plugin\BusinessRulesConditionManager;
+use Drupal\business_rules\Plugin\BusinessRulesVariable\CustomValueVariable;
+use Drupal\business_rules\Plugin\BusinessRulesVariableManager;
+use Drupal\business_rules\Util\BusinessRulesProcessor;
+use Drupal\business_rules\Util\BusinessRulesUtil;
+use Drupal\business_rules\Util\Flowchart\Flowchart;
+use Drupal\business_rules\VariablesSet;
+use Drupal\Component\Uuid\UuidInterface;
+use Drupal\Core\Config\ConfigFactoryInterface;
+use Drupal\Core\Config\ImmutableConfig;
+use Drupal\Core\Config\StorageInterface;
+use Drupal\Core\DependencyInjection\ContainerBuilder;
+use Drupal\Core\Entity\EntityFieldManagerInterface;
+use Drupal\Core\Entity\EntityStorageInterface;
+use Drupal\Core\Entity\EntityTypeBundleInfoInterface;
+use Drupal\Core\Entity\EntityTypeManagerInterface;
+use Drupal\Core\Entity\EntityTypeRepositoryInterface;
+use Drupal\Core\Extension\ModuleHandlerInterface;
+use Drupal\Core\Field\FieldTypePluginManagerInterface;
+use Drupal\Core\KeyValueStore\KeyValueExpirableFactory;
+use Drupal\Core\Logger\LoggerChannelFactory;
+use Drupal\Core\Utility\Token;
+use Drupal\Tests\UnitTestCase;
+use Symfony\Component\EventDispatcher\EventDispatcherInterface;
+use Symfony\Component\HttpFoundation\Request;
+use Symfony\Component\HttpFoundation\RequestStack;
+
+/**
+ * @coversDefaultClass \Drupal\business_rules\Util\BusinessRulesProcessor
+ *
+ * @group business_rules
+ */
+class BusinessRulesProcessorTest extends UnitTestCase {
+
+  /**
+   * The entity types plugin manager.
+   *
+   * @var \Drupal\Core\Entity\EntityTypeManagerInterface|\PHPUnit\Framework\MockObject\MockObject
+   */
+  protected $entityTypeManager;
+
+  /**
+   * The Business rules Variable plugin manager.
+   *
+   * @var \Drupal\business_rules\Plugin\BusinessRulesVariableManager|\PHPUnit\Framework\MockObject\MockObject
+   */
+  protected $businessRulesVariableManager;
+
+  /**
+   * The Business rules Processor.
+   *
+   * @var \Drupal\business_rules\Util\BusinessRulesProcessor|\PHPUnit\Framework\MockObject\MockObject
+   */
+  protected $businessRulesProcessor;
+
+  protected function setUp() {
+    parent::setUp();
+
+    $container = new ContainerBuilder();
+    // The following services are required by the business_rules.util service.
+
+    $container->set('entity_field.manager', $this->createMock(EntityFieldManagerInterface::class));
+    $container->set('plugin.manager.field.field_type', $this->createMock(FieldTypePluginManagerInterface::class));
+    $container->set('entity_type.bundle.info', $this->createMock(EntityTypeBundleInfoInterface::class));
+
+    // Service config.factory must return an immutable config instance.
+    $config = $this->createMock(ImmutableConfig::class);
+    $configFactory = $this->createMock(ConfigFactoryInterface::class);
+    $configFactory->expects($this->any())
+      ->method('get')
+      ->willReturn($config);
+    $container->set('config.factory', $configFactory);
+
+    $this->entityTypeManager = $this->createMock(EntityTypeManagerInterface::class);
+    $container->set('entity_type.manager', $this->entityTypeManager);
+    $this->businessRulesVariableManager = $this->createMock(BusinessRulesVariableManager::class);
+    $container->set('plugin.manager.business_rules.variable', $this->businessRulesVariableManager);
+
+    // Service request_stack must return the current request.
+    $request = $this->createMock(Request::class);
+    $requestStack = $this->createMock(RequestStack::class);
+    $requestStack->expects($this->any())
+      ->method('getCurrentRequest')
+      ->willReturn($request);
+    $container->set('request_stack', $requestStack);
+    $container->set('logger.factory', $this->createMock(LoggerChannelFactory::class));
+    $container->set('keyvalue.expirable', $this->createMock(KeyValueExpirableFactory::class));
+    $container->set('business_rules.flowchart', $this->createMock(Flowchart::class));
+    $container->set('module_handler', $this->createMock(ModuleHandlerInterface::class));
+    $container->set('token', $this->createMock(Token::class));
+
+    // Instantiate real business_rules.util service class.
+    $container->set('business_rules.util', new BusinessRulesUtil($container));
+
+    // The following services are required by the business_rules.processor
+    // service.
+    $container->set('uuid', $this->createMock(UuidInterface::class));
+    $container->set('event_dispatcher', $this->createMock(EventDispatcherInterface::class));
+    $container->set('config.storage', $this->createMock(StorageInterface::class));
+    $container->set('entity_type.repository', $this->createMock(EntityTypeRepositoryInterface::class));
+    $container->set('plugin.manager.business_rules.action', $this->createMock(BusinessRulesActionManager::class));
+    $container->set('plugin.manager.business_rules.condition', $this->createMock(BusinessRulesConditionManager::class));
+
+    // Instantiate mocked business_rules.processor service class due to the fact
+    // that __destruct() method causes PHP fatal error during the test
+    // exectution.
+    $this->businessRulesProcessor = $this->getMockBuilder(BusinessRulesProcessor::class)
+      ->enableOriginalConstructor()
+      ->setConstructorArgs([$container])
+      ->setMethods(['__destruct'])
+      ->getMock();
+    $container->set('business_rules.processor', $this->businessRulesProcessor);
+
+    \Drupal::setContainer($container);
+  }
+
+  /**
+   * @covers ::evaluateVariable
+   */
+  public function testEvaluateVariableMultipleEventsWithinSingleRequest() {
+
+    $entityStorage = $this->createMock(EntityStorageInterface::class);
+    $this->entityTypeManager->expects($this->any())
+      ->method('getStorage')
+      ->willReturn($entityStorage);
+
+    // Create a variable to test against.
+    $variable = new Variable([
+      'id' => 'test_variable',
+      'type' => 'custom_value_variable',
+      'settings' => [
+        'value' => 'test_value',
+      ],
+    ]);
+
+    // Ensure that variable is being loaded by the entity storage.
+    $entityStorage->expects($this->any())
+      ->method('load')
+      ->willReturnMap([
+        ['test_variable', $variable],
+    ]);
+
+    // Ensure that variable definition is available.
+    $this->businessRulesVariableManager->expects($this->any())
+      ->method('getDefinition')
+      ->willReturnMap([
+        ['custom_value_variable', TRUE, ['class' => CustomValueVariable::class, 'id' => 'custom_value_variable']],
+    ]);
+
+    // Service business_rules.processor requires a business rule to operate.
+    $rule = $this->createMock(BusinessRule::class);
+    $this->businessRulesProcessor->ruleBeingExecuted = $rule;
+
+    // Test against the simpliest event.
+    $dummy = new \stdClass();
+
+    $eventA = new BusinessRulesEvent($dummy, [
+      'entity_type_id' => '',
+      'bundle' => NULL,
+      'entity' => NULL,
+      'entity_unchanged' => NULL,
+      'loop_control' => 'event_A',
+      'variables' => new VariablesSet(),
+    ]);
+    $this->assertNotNull($this->businessRulesProcessor->evaluateVariable($variable, $eventA));
+
+    $eventB = new BusinessRulesEvent($dummy, [
+      'entity_type_id' => '',
+      'bundle' => NULL,
+      'entity' => NULL,
+      'entity_unchanged' => NULL,
+      'loop_control' => 'event_B',
+      'variables' => new VariablesSet(),
+    ]);
+    $this->assertNotNull($this->businessRulesProcessor->evaluateVariable($variable, $eventB));
+  }
+
+}