Sure. Firstly, if the logic in the internal method is complex enough, i'd strongly suggest extracting another class (say LogicClass) containing only that logic and test it independently. THEN you could use something like NSub to test the interaction between Class1 and your new LogicClass
Otherwise, here are some other options. (DISCLAIMER) Some of these ideas have their particularly useful occasions, but I wouldn't lean on some of them as a first option if I at all could avoid it
* Make DoSomeInternalLogic protected virtual. In your test class, create a subclass of Class1 and override "DoSomeInternalLogic" do perform no operations. Here, protected is used to give a similar veil of privacy that you'd get from "private"
* Similar alternative to above - create a base class BaseClass which contains the implementation of DoSomeLogic(bool), and an abstract definition for DoSomeInternalLogic. Class1 would inherit from BassClass and implement DoSomeInternalLogic. In your tests, create a class which subclasses BaseClass and implement DoSomeInternalLogic with no behaviour defined.
* Create a public field Func<int> DoSomeInternalLogicFunc which has the body of the DoSomeInternalLogic routine. Then in your test, replace the public Func with a func which does nothing.
* Switch to TypeMock Isolator. I havent used it, but i'm lead to believe it allows you to write tests directly against private methods
These are the ones which come to mind. The first three are variations on the concept of creating a seam which gives you access to change the behaviour of a specific part of code. I'm sure there are other patterns i've missed. If you're interested in finding more, I (and i'm certain lots of others on this mailing list) recommend the book Working Effectively With Legacy Code by Michael Feathers.