diff --git a/navalplanner-business/src/main/java/org/navalplanner/business/orders/entities/Order.java b/navalplanner-business/src/main/java/org/navalplanner/business/orders/entities/Order.java
index 31a6b0019..f3d4f128e 100644
--- a/navalplanner-business/src/main/java/org/navalplanner/business/orders/entities/Order.java
+++ b/navalplanner-business/src/main/java/org/navalplanner/business/orders/entities/Order.java
@@ -495,8 +495,19 @@ public class Order extends OrderLineGroup {
         scenarios.put(currentScenario, orderVersion);
     }
 
-    public void removeOrderVersionForScenario(Scenario scenario) {
-        scenarios.remove(scenario);
+    /**
+     * Disassociates this order and its children from the scenario
+     *
+     * @param scenario
+     * @return <code>null</code> if there is no order version for the scenario;
+     *         the order version associated to the supplied scenario
+     */
+    public OrderVersion disassociateFrom(Scenario scenario) {
+        OrderVersion existentVersion = scenarios.remove(scenario);
+        if (existentVersion != null) {
+            removeVersion(existentVersion);
+        }
+        return existentVersion;
     }
 
     public OrderVersion getOrderVersionFor(Scenario current) {
@@ -507,4 +518,17 @@ public class Order extends OrderLineGroup {
     public void setOrderVersion(Scenario scenario, OrderVersion newOrderVersion) {
         scenarios.put(scenario, newOrderVersion);
     }
+
+    public boolean hasNoVersions() {
+        return scenarios.isEmpty();
+    }
+
+    public boolean isVersionUsed(OrderVersion orderVersion) {
+        for (OrderVersion each : getScenarios().values()) {
+            if (each.getId().equals(orderVersion.getId())) {
+                return true;
+            }
+        }
+        return false;
+    }
 }
diff --git a/navalplanner-business/src/main/java/org/navalplanner/business/orders/entities/OrderElement.java b/navalplanner-business/src/main/java/org/navalplanner/business/orders/entities/OrderElement.java
index 608ced00e..1de8c582f 100644
--- a/navalplanner-business/src/main/java/org/navalplanner/business/orders/entities/OrderElement.java
+++ b/navalplanner-business/src/main/java/org/navalplanner/business/orders/entities/OrderElement.java
@@ -115,6 +115,13 @@ public abstract class OrderElement extends IntegrationEntity implements
 
     private Map<OrderVersion, SchedulingDataForVersion> schedulingDatasForVersion = new HashMap<OrderVersion, SchedulingDataForVersion>();
 
+    protected void removeVersion(OrderVersion orderVersion) {
+        schedulingDatasForVersion.remove(orderVersion);
+        for (OrderElement each : getChildren()) {
+            each.removeVersion(orderVersion);
+        }
+    }
+
     private SchedulingDataForVersion.Data current = null;
 
     public SchedulingDataForVersion.Data getCurrentSchedulingData() {
diff --git a/navalplanner-business/src/main/java/org/navalplanner/business/scenarios/entities/Scenario.java b/navalplanner-business/src/main/java/org/navalplanner/business/scenarios/entities/Scenario.java
index c975ed434..9a9238019 100644
--- a/navalplanner-business/src/main/java/org/navalplanner/business/scenarios/entities/Scenario.java
+++ b/navalplanner-business/src/main/java/org/navalplanner/business/scenarios/entities/Scenario.java
@@ -25,11 +25,13 @@ import static org.navalplanner.business.i18n.I18nHelper._;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.HashMap;
+import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
 import java.util.Map.Entry;
 
+import org.apache.commons.lang.ObjectUtils;
 import org.apache.commons.lang.StringUtils;
 import org.apache.commons.lang.Validate;
 import org.hibernate.validator.AssertTrue;
@@ -84,6 +86,16 @@ public class Scenario extends BaseEntity {
         this.predecessor = predecessor;
     }
 
+    public void removeVersion(OrderVersion orderVersion) {
+        Iterator<OrderVersion> iterator = orders.values().iterator();
+        while (iterator.hasNext()) {
+            OrderVersion each = iterator.next();
+            if (ObjectUtils.equals(orderVersion, each)) {
+                iterator.remove();
+            }
+        }
+    }
+
     public OrderVersion addOrder(Order order) {
         addOrder(order, OrderVersion.createInitialVersion(this));
         return orders.get(order);
diff --git a/navalplanner-webapp/src/main/java/org/navalplanner/web/orders/OrderModel.java b/navalplanner-webapp/src/main/java/org/navalplanner/web/orders/OrderModel.java
index 3cdd066b0..86f9d7bd5 100644
--- a/navalplanner-webapp/src/main/java/org/navalplanner/web/orders/OrderModel.java
+++ b/navalplanner-webapp/src/main/java/org/navalplanner/web/orders/OrderModel.java
@@ -643,45 +643,60 @@ public class OrderModel implements IOrderModel {
 
     @Override
     @Transactional
-    public void remove(Order order) {
-        if (order.getScenarios().size() == 1) {
-            try {
-                orderDAO.remove(order.getId());
-            } catch (InstanceNotFoundException e) {
-                throw new RuntimeException(e);
-            }
-        } else {
-            orderDAO.save(order);
+    public void remove(Order detachedOrder) {
+        Order order = orderDAO.findExistingEntity(detachedOrder.getId());
+        removeVersions(order);
+        if (order.hasNoVersions()) {
+            removeOrderFromDB(order);
+        }
+    }
 
-            Scenario scenario = scenarioManager.getCurrent();
-            OrderVersion currentOrderVersion = scenario.getOrderVersion(order);
-            order.removeOrderVersionForScenario(scenario);
+    private void removeVersions(Order order) {
+        Map<Long, OrderVersion> versionsRemovedById = new HashMap<Long, OrderVersion>();
+        List<Scenario> currentAndDerived = currentAndDerivedScenarios();
+        for (Scenario each : currentAndDerived) {
+            OrderVersion versionRemoved = order.disassociateFrom(each);
+            if (versionRemoved != null) {
+                versionsRemovedById.put(versionRemoved.getId(), versionRemoved);
+            }
+        }
+        for (OrderVersion each : versionsRemovedById.values()) {
+            if (!order.isVersionUsed(each)) {
+                removeOrderVersionAt(each, currentAndDerived);
+                removeOrderVersionFromDB(each);
+            }
+        }
+    }
 
-            derivedScenarios = scenarioDAO.getDerivedScenarios(scenario);
-            for (Scenario derivedScenario : derivedScenarios) {
-                OrderVersion orderVersion = order
-                        .getOrderVersionFor(derivedScenario);
-                if ((orderVersion != null)
-                        && (orderVersion.getId()
-                                .equals(currentOrderVersion.getId()))) {
-                    order.removeOrderVersionForScenario(derivedScenario);
-                }
-            }
+    private void removeOrderVersionAt(OrderVersion orderVersion,
+            Collection<? extends Scenario> currentAndDerived) {
+        for (Scenario each : currentAndDerived) {
+            each.removeVersion(orderVersion);
+        }
+    }
 
-            boolean orderVersionNotUsed = true;
-            for (OrderVersion orderVersion : order.getScenarios().values()) {
-                if (orderVersion.getId().equals(currentOrderVersion.getId())) {
-                    orderVersionNotUsed = false;
-                    break;
-                }
-            }
-            if (orderVersionNotUsed) {
-                try {
-                    orderVersionDAO.remove(currentOrderVersion.getId());
-                } catch (InstanceNotFoundException e) {
-                    throw new RuntimeException(e);
-                }
-            }
+    private List<Scenario> currentAndDerivedScenarios() {
+        List<Scenario> scenariosToBeDisassociatedFrom = new ArrayList<Scenario>();
+        Scenario currentScenario = scenarioManager.getCurrent();
+        scenariosToBeDisassociatedFrom.add(currentScenario);
+        scenariosToBeDisassociatedFrom.addAll(scenarioDAO
+                .getDerivedScenarios(currentScenario));
+        return scenariosToBeDisassociatedFrom;
+    }
+
+    private void removeOrderVersionFromDB(OrderVersion currentOrderVersion) {
+        try {
+            orderVersionDAO.remove(currentOrderVersion.getId());
+        } catch (InstanceNotFoundException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    private void removeOrderFromDB(Order order) {
+        try {
+            orderDAO.remove(order.getId());
+        } catch (InstanceNotFoundException e) {
+            throw new RuntimeException(e);
         }
     }
 
diff --git a/navalplanner-webapp/src/main/java/org/navalplanner/web/scenarios/ScenarioModel.java b/navalplanner-webapp/src/main/java/org/navalplanner/web/scenarios/ScenarioModel.java
index b93052b4c..19b258c7e 100644
--- a/navalplanner-webapp/src/main/java/org/navalplanner/web/scenarios/ScenarioModel.java
+++ b/navalplanner-webapp/src/main/java/org/navalplanner/web/scenarios/ScenarioModel.java
@@ -149,7 +149,7 @@ public class ScenarioModel implements IScenarioModel {
                     }
                 }
             } else {
-                order.removeOrderVersionForScenario(scenario);
+                order.disassociateFrom(scenario);
                 orderDAO.save(order);
             }
         }