diff -Naur field_collection_old/field_collection.module field_collection/field_collection.module
--- field_collection_old/field_collection.module	2013-05-22 12:30:06.000000000 +0100
+++ field_collection/field_collection.module	2013-05-22 12:31:11.000000000 +0100
@@ -394,7 +394,62 @@
     }
     return !empty($this->hostEntityId) || !empty($this->hostEntity) || !empty($this->hostEntityRevisionId);
   }
-
+  /**
+   * Fetch an assosciative array of all non deleted entities, other than the
+   * (optionally) passed host entity that are using this field collection.
+   * Optionally retrieve only those entities using the current revision
+   *
+   * This is needed to account for ...
+   * 1) node revisions being removed from the database before deleteRevision is
+   *    called
+   * 2) Multiple host entities referring to the same field collection as a result
+   *    of migration from an older version of field collection
+   *
+   * We don't want to clobber those field collections on deleteRevision, so
+   * we check for references here, in this nasty, hacky piece of code :-)
+   *
+   * @param bool $for_current_revision_only
+   * @param int $exclude_this_revision_id
+   * @return array
+   * @throws Exception
+   */
+  protected function fetchAllHostEntityIds($for_current_revision_only = FALSE, $exclude_this_revision_id = NULL) {
+    $results = array();
+    if ($this->item_id) {
+      $entity_type = $this->hostEntityType();
+      $entity_info = entity_get_info($entity_type);
+      if (empty($entity_info['entity keys']['revision'])) {
+        throw new Exception('fetchAllHostEntityIds only operates on revisioned entities');
+      }
+      // Retrieve data from field tables using EntityFieldQuery
+      $query = new EntityFieldQuery();
+      if($for_current_revision_only) {
+        $query->fieldCondition($this->fieldInfo(), 'revision_id', $this->revision_id);
+      }
+      else {
+        $query->fieldCondition($this->fieldInfo(), 'value', $this->item_id);
+      }
+      $query->age(FIELD_LOAD_REVISION);
+      $entities = $query->execute();
+      if (isset($entities[$entity_type]) && $entities[$entity_type]) {
+        // EntityFieldQuery can fetch host entity revision ids that have already
+        // been delted from the database. Check our ids exist.
+        $revisions_for_query = array_keys($entities[$entity_type]);
+        $squery = db_select($entity_info['revision table'], 'revision');
+        $squery->fields('revision', array($entity_info['entity keys']['id'], $entity_info['entity keys']['revision']))
+               ->condition($entity_info['entity keys']['revision'], $revisions_for_query, 'IN');
+        $revisions = $squery->execute()->fetchAllAssoc($entity_info['entity keys']['revision']);
+        if($revisions) {
+          foreach ($revisions as $rid => $revision) {
+            if($rid != $exclude_this_revision_id) {
+              $results[$rid] = $entities[$entity_type][$rid];
+            }
+          }
+        }
+      }
+    }
+    return $results;
+  }
   /**
    * Determines the $delta of the reference pointing to this field collection
    * item.
@@ -525,24 +580,36 @@
    * If no revisions are left or the host is not revisionable, the whole item
    * is deleted.
    */
-  public function deleteRevision($skip_host_update = FALSE) {
+  public function deleteRevision($skip_host_update = FALSE, $calling_host_entity_revision_id = NULL) {
     if (!$this->revision_id) {
       return;
     }
     $info = entity_get_info($this->hostEntityType());
-    if (empty($info['entity keys']['revision']) || !$this->hostEntity()) {
+    if (empty($info['entity keys']['revision'])) {
       return $this->delete();
     }
-    if (!$skip_host_update) {
+    // When called from node_revision_delete, the host entity has already been
+    // removed from the database, but other entities can still refer to the field
+    // collection. Retrieve those entities here.
+    $host_entities = $this->fetchAllHostEntityIds(FALSE, $calling_host_entity_revision_id);
+    if (! $host_entities) {
+      return $this->delete();
+    }
+    // After running update.php from a site with old unversioned field
+    // collections, there can be multiple host entities using the same
+    // revision. We do NOT want to delete the revision if it's
+    // still being referenced. This checks for that condition.
+    $host_entities_using_this_revision = $this->fetchAllHostEntityIds(TRUE, $calling_host_entity_revision_id);
+    if (!$skip_host_update && $this->hostEntity()) {
       // Just remove the item from the host, which cares about deleting the
       // item (depending on whether the update creates a new revision).
       $this->deleteHostEntityReference();
     }
-    elseif (!$this->isDefaultRevision()) {
+    elseif (!$this->isDefaultRevision() && !$host_entities_using_this_revision) {
       entity_revision_delete('field_collection_item', $this->revision_id);
     }
     // If deleting the default revision, take care!
-    else {
+    elseif (!$host_entities_using_this_revision) {
       $row = db_select('field_collection_item_revision', 'r')
         ->fields('r')
         ->condition('item_id', $this->item_id)
@@ -948,7 +1015,7 @@
     else {
       // Delete unused field collection items now.
       foreach (field_collection_item_load_multiple($ids) as $item) {
-        $item->deleteRevision(TRUE);
+        $item->deleteRevision(TRUE, field_collection_get_revision_id($entity_type, $entity));
       }
     }
   }
@@ -990,8 +1057,8 @@
 function field_collection_field_delete_revision($entity_type, $entity, $field, $instance, $langcode, &$items) {
   foreach ($items as $item) {
     if (!empty($item['revision_id'])) {
-      if ($entity = field_collection_item_revision_load($item['revision_id'])) {
-        $entity->deleteRevision(TRUE);
+      if ($field_collection = field_collection_item_revision_load($item['revision_id'])) {
+        $field_collection->deleteRevision(TRUE, field_collection_get_revision_id($entity_type, $entity));
       }
     }
   }
@@ -1862,3 +1929,18 @@
 
   return array('value' => $field_collection->item_id);
 }
+/**
+ * Get revision ID from a passed entity
+ *
+ * @param string $entity_type
+ * @param object $entity
+ * @return null|int
+ */
+function field_collection_get_revision_id($entity_type, $entity) {
+  $ids = entity_extract_ids($entity_type, $entity);
+  $vid = NULL;
+  if(is_array($ids)) {
+    list($id, $vid, $bundle) = $ids;
+  }
+  return $vid;
+}
\ No newline at end of file
diff -Naur field_collection_old/field_collection.test field_collection/field_collection.test
--- field_collection_old/field_collection.test	2013-05-22 12:30:06.000000000 +0100
+++ field_collection/field_collection.test	2013-05-22 12:32:53.000000000 +0100
@@ -158,11 +158,9 @@
     $node_vid = $node->vid;
     $node->revision = TRUE;
     node_save($node);
-
     $node_vid2 = $node->vid;
     $node->revision = TRUE;
     node_save($node);
-
     // Now delete the field collection item for the default revision.
     $item = field_collection_item_load($node->{$this->field_name}[LANGUAGE_NONE][0]['value']);
     $item_revision_id = $item->revision_id;
@@ -210,6 +208,20 @@
     $item = field_collection_item_load($item->item_id);
     $this->assertTrue($item, 'Removed field collection item still exists.');
     $this->assertTrue($item->archived, 'Removed field collection item is archived.');
+
+    // Test removing an old node revision. Make sure that the field collection
+    // is not removed
+    list ($node, $item) = $this->createNodeWithFieldCollection();
+    $node_vid = $node->vid;
+    $node->revision = TRUE;
+    node_save($node);
+    $node_vid2 = $node->vid;
+    $item_vid2 = $node->{$this->field_name}[LANGUAGE_NONE][0]['revision_id'];
+    node_revision_delete($node_vid);
+    $item2 = field_collection_item_revision_load($item_vid2);
+    $item_id2 = isset($item2->item_id) ? $item2->item_id : -1;
+    $this->assertEqual($item_id2, $item->item_id, 'Removing an old node revision does not delete newer field collection revisions');
+
   }
 
   /**