diff --git a/plugins/org.eclipse.objectteams.otequinox/src/org/eclipse/objectteams/internal/osgi/weaving/AspectBinding.java b/plugins/org.eclipse.objectteams.otequinox/src/org/eclipse/objectteams/internal/osgi/weaving/AspectBinding.java
index 3f35a46..81c5b2b 100644
--- a/plugins/org.eclipse.objectteams.otequinox/src/org/eclipse/objectteams/internal/osgi/weaving/AspectBinding.java
+++ b/plugins/org.eclipse.objectteams.otequinox/src/org/eclipse/objectteams/internal/osgi/weaving/AspectBinding.java
@@ -82,6 +82,8 @@
 		boolean importsAddedToSub;
 
 		final List<String> baseClassNames = new ArrayList<>();
+		
+		public final List<String> superBases = new ArrayList<>(); // logging / debugging only
 
 		public TeamBinding(String teamName, ActivationKind activationKind, @Nullable String superTeamName) {
 			this.teamName = teamName;
@@ -189,7 +191,10 @@
 
 		@Override
 		public String toString() {
-			return "team "+teamName+"("+(this.activation)+") super "+superTeamName;
+			String result = "team "+teamName+"("+(this.activation)+") super "+superTeamName;
+			for (String superBase : superBases)
+				result += "\n\t\t\tsuperBase "+superBase;
+			return result;
 		}
 
 		/** Get the highest activation kind from this team and its equivalents. */
diff --git a/plugins/org.eclipse.objectteams.otequinox/src/org/eclipse/objectteams/internal/osgi/weaving/AspectBindingRegistry.java b/plugins/org.eclipse.objectteams.otequinox/src/org/eclipse/objectteams/internal/osgi/weaving/AspectBindingRegistry.java
index 6a7c324..c10a7ba 100644
--- a/plugins/org.eclipse.objectteams.otequinox/src/org/eclipse/objectteams/internal/osgi/weaving/AspectBindingRegistry.java
+++ b/plugins/org.eclipse.objectteams.otequinox/src/org/eclipse/objectteams/internal/osgi/weaving/AspectBindingRegistry.java
@@ -93,7 +93,7 @@
 		IConfigurationElement[] aspectBindingConfigs = extensionRegistry
 				.getConfigurationElementsFor(TRANSFORMER_PLUGIN_ID, ASPECT_BINDING_EXTPOINT_ID);
 		Map<String, Set<TeamBinding>> teamLookup = new HashMap<>();
-		AspectBinding[] bindings = new AspectBinding[aspectBindingConfigs.length];
+		List<AspectBinding> bindings = new ArrayList<>(aspectBindingConfigs.length);
 		
 		for (int i = 0; i < aspectBindingConfigs.length; i++) {
 			IConfigurationElement currentBindingConfig = aspectBindingConfigs[i];
@@ -138,7 +138,7 @@
 														baseBundle,
 														basePlugins[0].getChildren(Constants.FORCED_EXPORTS_ELEMENT),
 														teamCount);
-			bindings[i] = binding;
+			bindings.add(binding);
 			// TODO(SH): maybe enforce that every bundle id is given only once?
 
 			//teams:
@@ -153,7 +153,9 @@
 					teamSet.add(team);
 					
 					for (@NonNull IConfigurationElement superBase : teams[j].getChildren(SUPER_BASE)) {
-						addSuperBases(superBase, aspectBundleId, aspectBundle, baseBundle, team, packageAdmin, hook);
+						AspectBinding superBaseBinding = addSuperBase(superBase, aspectBundleId, aspectBundle, baseBundle, team, packageAdmin, hook);
+						bindings.add(superBaseBinding);
+						teamSet.add(superBaseBinding.teams[0]);
 					}
 				}
 				
@@ -168,12 +170,12 @@
 			}
 		}
 		// second round to connect sub/super teams to aspect bindings:
-		for (int i = 0; i < bindings.length; i++) {
-			bindings[i].connect(teamLookup);
+		for (AspectBinding binding : bindings) {
+			binding.connect(teamLookup);
 		}
 	}
 
-	private void addSuperBases(IConfigurationElement superBase, String aspectBundleId, @Nullable Bundle aspectBundle,
+	private AspectBinding addSuperBase(IConfigurationElement superBase, String aspectBundleId, @Nullable Bundle aspectBundle,
 			BaseBundle baseBundle, TeamBinding teamBinding,
 			@SuppressWarnings("deprecation") @Nullable org.osgi.service.packageadmin.PackageAdmin packageAdmin,
 			OTWeavingHook hook)
@@ -191,11 +193,13 @@
 		TeamBinding team2 = superBinding.createResolvedTeam(0, teamBinding.teamName, NONE, teamBinding.superTeamName);
 		superBinding.allBaseClassNames.add(superBaseClass);
 		team2.baseClassNames.add(superBaseClass);
-		team2.equivalenceSet.add(teamBinding);
-		teamBinding.equivalenceSet.add(team2);
 		addBindingForBaseBundle(superBasePlugin, superBinding);
 		addBindingForAspectBundle(aspectBundleId, superBinding);
-		hook.setBaseTripWire(packageAdmin, superBasePlugin, baseBundle);
+		hook.setBaseTripWire(packageAdmin, superBasePlugin, superBaseBundle);
+		
+		teamBinding.superBases.add(superBasePlugin+'/'+superBaseClass);
+
+		return superBinding;
 	}
 
 	@SuppressWarnings("deprecation") // multiple uses of deprecated but still recommended class PackageAdmin
