diff --git a/src/main/java/org/springframework/classify/BinaryExceptionClassifier.java b/src/main/java/org/springframework/classify/BinaryExceptionClassifier.java
index a326f76..2f374e4 100644
--- a/src/main/java/org/springframework/classify/BinaryExceptionClassifier.java
+++ b/src/main/java/org/springframework/classify/BinaryExceptionClassifier.java
@@ -110,7 +110,7 @@ public class BinaryExceptionClassifier extends SubclassClassifier<Throwable, Boo
 		if (classified.equals(this.getDefault())) {
 			Throwable cause = classifiable;
 			do {
-				if (this.getClassified().containsKey(classifiable.getClass())) {
+				if (this.getClassified().containsKey(cause.getClass())) {
 					return classified; // non-default classification
 				}
 				cause = cause.getCause();
diff --git a/src/test/java/org/springframework/classify/BinaryExceptionClassifierTests.java b/src/test/java/org/springframework/classify/BinaryExceptionClassifierTests.java
index b99103f..8070753 100644
--- a/src/test/java/org/springframework/classify/BinaryExceptionClassifierTests.java
+++ b/src/test/java/org/springframework/classify/BinaryExceptionClassifierTests.java
@@ -21,9 +21,13 @@ import static org.junit.Assert.assertTrue;
 
 import java.util.Collection;
 import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
 
 import org.junit.Test;
 
+import org.springframework.beans.DirectFieldAccessor;
+
 public class BinaryExceptionClassifierTests {
 
 	BinaryExceptionClassifier classifier = new BinaryExceptionClassifier(false);
@@ -65,6 +69,27 @@ public class BinaryExceptionClassifierTests {
 		assertTrue(binaryExceptionClassifier.classify(new RuntimeException(new IllegalStateException("Foo"))));
 	}
 
+	@Test
+	public void testClassifySubclassMatchInCause() {
+		Collection<Class<? extends Throwable>> set = Collections
+				.<Class<? extends Throwable>> singleton(IllegalStateException.class);
+		BinaryExceptionClassifier binaryExceptionClassifier = new BinaryExceptionClassifier(set);
+		binaryExceptionClassifier.setTraverseCauses(true);
+		assertTrue(binaryExceptionClassifier.classify(new RuntimeException(new FooException("Foo"))));
+	}
+
+	@Test
+	public void testClassifySubclassMatchInCauseFalse() {
+		Map<Class<? extends Throwable>, Boolean> map = new HashMap<Class<? extends Throwable>, Boolean>();
+		map.put(IllegalStateException.class, true);
+		map.put(BarException.class, false);
+		BinaryExceptionClassifier binaryExceptionClassifier = new BinaryExceptionClassifier(map, true);
+		binaryExceptionClassifier.setTraverseCauses(true);
+		assertTrue(binaryExceptionClassifier.classify(new RuntimeException(new FooException("Foo", new BarException()))));
+		assertTrue(((Map<?, ?>) new DirectFieldAccessor(binaryExceptionClassifier).getPropertyValue("classified"))
+				.containsKey(FooException.class));
+	}
+
 	@Test
 	public void testTypesProvidedInConstructor() {
 		classifier = new BinaryExceptionClassifier(Collections
@@ -86,4 +111,26 @@ public class BinaryExceptionClassifierTests {
 		classifier.setTraverseCauses(true);
 		assertFalse(classifier.classify(new RuntimeException(new RuntimeException(new IllegalStateException("Foo")))));
 	}
+
+	@SuppressWarnings("serial")
+	private class FooException extends IllegalStateException {
+
+		private FooException(String s) {
+			super(s);
+		}
+
+		private FooException(String s, Throwable t) {
+			super(s, t);
+		}
+
+	}
+
+	@SuppressWarnings("serial")
+	private class BarException extends RuntimeException {
+
+		private BarException() {
+			super();
+		}
+
+	}
 }