Is there ever a time when one of the methods would throw an exception and the other would not?
Yes, there are differences between the two. For example, you can't cast a String to an Integer, but you can use Integer.valueOf to parse a String into an Integer. As a side effect, this means that different constructs are susceptible to different errors. For example:
Object o = '32';
// Following line would throw a runtime exception
//Integer i1 = (Integer)o;
// But this line will return the value 32.
Integer i2 = Integer.valueOf(o);
Is one more performant than the other?
Casting is always faster, but only handles "legal" conversions, such as converting a Decimal or Long to an Integer. An analysis I just did suggests that casting is about 7.8 times faster than using Integer.valueOf, with casting requiring about 0.001679 milliseconds, and Integer.valueOf requiring about 0.013072 milliseconds (edit: normalized out the time required to execute a loop for better comparison).
(Additional Edit): The difference between casting and Integer.valueOf becomes increasingly more pronounced the more verbose your profiling and system log levels are set to. Cranking everything down to a bare minimum, and normalizing the loop and heap allocations, shows that casting is about 0.0008 milliseconds, while Integer.valueOf is about 0.00114 milliseconds, which isn't even twice as expensive. However, since most users operate at a level higher than "no debugging at all", the previous paragraph fairly accurately expresses the typical performance penalty you can expect for a normal production user.
Other than code consistency is there any reason to standardize on one approach?
You should always prefer performance over standardization, but be aware that both casting and valueOf are tools that have different purposes (so you should ideally use both as appropriate). Use casting when you know that you're using a legal cast type, such as Decimal or Long, and use Integer.valueOf when you need the flexibility of also parsing strings.