What is the most secure key expansion routine? I am looking at G now, but is there a better, (in terms of security and speed), means by which a byte array can be expanded that doesn't involve another cipher, just a simple algorithm?

I need to expand 1024 bytes to 4096 for use in a stream cipher, and speed is less important than overall distribution of entropy. I am also trying to find something that is strictly algorithmic, that doesn't employ hashing or another cipher. Any thoughts/recommendations?
There are many possibilities here, depending on the particulars of where exactly you will use it.


Your use case may require a random looking derived key, where the 1024 bytes of entropy have been distributed evenly over all the bytes of the final key. In that case there's no avoiding a key derivation function. You will have to use either a block cipher, a hash function, or something equally complex.
Your use of it in a stream cipher may not care at all, if the entropy will be subsequently diffused over the state anyway (maybe with extra initial rounds). In that case you may as well just set the rest of the bytes to zero, or perhaps concatenate four copies of the original key to increase the speed of initial diffusion.
The second point above may be true, but your cipher may have internal symmetries that could make certain bits or bytes "cancel out". In that case you may have to make sure the initial configuration does not lead to weaknesses due to that symmetry.
You may have some sort of security proof or reduction for the structure of the cipher, like a Feistel network has, for example. That could put requirements on the key, e.g. that certain parts have to differ. HMAC is an example where simply padding the key with two different bit patterns was sufficient for proofs.


In the end, the main guidance I would give out is to look at what other stream ciphers are doing. The eSTREAM winners would be a decent starting place.