
<p class="has-drop-cap wp-block-paragraph">1Under 36 år med start på 1960-talet var kuskmatchen Charlie Mills Trot en riktig höjdare på Romme. Mångårige sekreteraren och sportchefen på dalatravet, Bernth Martinsson, höll i tåtarna med hjälp av Elitloppsgeneralen Rune Stolt när stjärnkuskar från hela världen gjorde resan till Dalarna.</p>



<p class="wp-block-paragraph">”<em>Att få se Frömming, Krüger, O’Brien, Gougeon, Miller, Haughton, Baldis, Wewering, Thoresen, Kontio, bröderna Nordin, Stig H, Goop, Lindstedt, körsvenner från exotiska Australien och Nya Zeeland med flera på lilla Romme var en sensation som varje år lockade en jättepublik</em>,” skriver Martinsson själv i banprogrammet till kvällens tävlingar.</p>



<p class="wp-block-paragraph">Charlie Mills största av alla stjärnor var <strong>Gèlinotte</strong> (e. Kairos-Rhyticére), 1.16,7k*/955.990 franc. Gèlinotte vann två år i rad Elitloppet, Prix d&#8217;Amérique, Prix de France och Prix de Paris. Därutöver segrade hon i dubbla upplagor av Åby Stora Pris och segrade en tredje gång i Prix de Paris.</p>



<p class="wp-block-paragraph">2001 kördes kuskmatchen till den tyske kusk- och tränarvirtuosen för sista gången. Sedan 2002 har istället Romme låtit honom namnge ett långlopp, som från början hade 150.000 kronor i förstapris och vars premiärupplaga vanns av <strong>Viktor Gwin</strong> (e. Count’s Pride) och Tommy Hanné. Ikväll gör 15 hästar upp om 60.000 kronor i Charlie Mills Trot över tre varv.</p>



<p class="has-text-align-center wp-block-paragraph">***</p>



<p class="has-drop-cap wp-block-paragraph">2Romme (första start 18.30) delar fredagskvällens expresstrav med Kalmar (start 18.20), där ett annat flerklasslopp pockar på uppmärksamhet. Hästägarekannan med 40.000 kronor i förstapris ser 15 deltagare utspridda på fyra volter över medeldistans och längst bak finns Joakim Lövgrens kapable nioåring<strong> Staro Leonardo</strong> (e. Make It Happen).</p>



<p class="wp-block-paragraph">0-d-d-d-k lyder resultatraden för hästen med 2,5 miljoner kronor på kontot när han. Nu är tillbaka i tävlingssammanhang efter att ha tvingats till kvallopp efter sina tre raka diskvalifikationer. Förra året slog Staro Leonardo bland annat in en kvarts miljon kronor vid segern i Malmö Stads Pris under Åbergskvällen på hemmaplan.</p>



<p class="wp-block-paragraph">Förra året blev det hemmaseger i Hästägarekannan genom Elisabeth Almhedens<strong> A Fair Day </strong>(e. Maharajah) och Oscar Ginman). </p>



<p class="wp-block-paragraph">I Kalmar är det också sista chansen att kvala in till finalerna i två av banans årslånga löpningar, stoserien och stayerserien, som avgörs om två veckor med 150.000 kronor i förstapris i varje.</p>



<p class="has-text-align-center wp-block-paragraph">***</p>



<p class="has-drop-cap wp-block-paragraph">3Med två raka segrar på 1.14-tider över medeldistans med voltstart har Björn Goop-tränade treåringen <strong>Cameron Hills</strong> (e. Muscle Hill) inlett tävlingskarriären på allra bästa sätt. Idag när Färjestad (första start 12.20) drar igång tävlingarna på svensk mark ska Cameron Hills försöka förlänga segersviten i ett treåringslopp.</p>



<figure class="wp-block-image alignright size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2021/09/bjorngoop-617x333.jpg" alt="" class="wp-image-207314"/><figcaption class="wp-element-caption">Björn Goops Cameron Hills jagar tredje segern på Färjestad. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="wp-block-paragraph">Det ser ut att bli en hel del Björn Goop denna lunch. Nio hästar från stallet plockas ut till start och Björn kör sju av dessa. En är tyske<strong> J.J.Stitch </strong>(e. Maharajah), som vann sommartravets final för två år sedan, men efter en galoppmiss försvann han från tävlingsbanan – och även från Goops stall – i nästan två år. Återkomsten skedde i Årjäng för knappt tre veckor sedan där hästen dock gjorde en slät figur som oplacerad. Nu tar Goop och J.J.Stitch nya tag.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2023/09/230908.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till fredagens tävlingar.</a></p>



<p class="has-text-align-center wp-block-paragraph">***</p>



<p class="has-drop-cap wp-block-paragraph">4Trots att fyra banor tävlar på fransk mark denna fredag så är det blott på Vincennes (första start kl. 16.38) som det finns ett ynka svenskhopp.</p>



<p class="wp-block-paragraph">Då handlar det om Laurent Claude Abrivards <strong>Miss Irma</strong> (e. Mister J.P.) som jagar första årssegern för sadel i Prix Andre Rouer (€42.000) i lag med Thomas Roullier.<br>Loppet är lärlingslopp för fem- och sexåriga ston som högst tjänat 95.000 euro och lockar med 18.900 euro till segraren. Klart mer än vad den häst som går segrande ur striden i morgondagens Gulddivisionslopp kammar hem!</p>



<p class="has-text-align-center wp-block-paragraph">***</p>



<p class="has-drop-cap wp-block-paragraph">5Höstfavoriten för såväl hingstar och valacker som ston avgörs på Solvalla nu på onsdag och det sker med fina 200.000 kronor i segerpremie i respektive lopp.</p>



<p class="wp-block-paragraph">Pojkarnas klass med <strong>S.G.Dracarys</strong> (e. Bold Eagle) samt<strong> Frank S.H. </strong>(e. Fourth Dimension) som slutade tvåa och trea i korta E3-finalen har placerats före V86-spelet tar vid medan stonas upplaga med E3-tvåan, trean, fyran samt femman <strong>Larah Westwood</strong> (e. The Bank), <strong>Kinglet Bird</strong> (e. Nuncio), <strong>Knickers Sisu </strong>(e. Southwind Frank) och <strong>Willa Explosive</strong> (e. Explosive Matter) fått plats inom V86-spelet.</p>



<p class="wp-block-paragraph"><strong>Startlista Höstfavoriten hingstar och valacker</strong><br><em>2.140 meter autostart, förstapris: 200.000 kronor</em></p>



<ol class="wp-block-list">
<li>Kojak Sisu (e. Muscle Mass) – Mats E Djuse (Timo Nurmos)</li>



<li>Stens Rubin (e. Readly Express) – Erik Adielsson (Johan Untersteiner)</li>



<li>S.G.Dracarys (e. Bold Eagle) – Örjan Kihlström (Roger Walmann)</li>



<li>Global Etalon (e. Brillantissime) – Fredrik Wallin</li>



<li>Maco Toro (e. Nuncio) – Magnus A Djuse (Mattias Djuse)</li>



<li>Holcombe Zet (e. Daley Lovin) – Rikard N Skoglund (Daniel Redén)</li>



<li>Frank S.H. (e. Fourth Dimension) – Fredrik Persson</li>



<li>Loveislove Pellini (e. Muscle Mass) – Fredrik B Larsson</li>
</ol>



<p class="wp-block-paragraph"><strong>Startlista Höstfavoriten ston</strong><br><em>2.140 meter autostart, förstapris: 200.000 kronor</em></p>



<ol class="wp-block-list">
<li>Whoopsy Laday (e. Tobin Kronos) – Rikard N Skoglund (Timo Nurmos)</li>



<li>Käraste Sisu (e. Face Time Bourbon) – Mika Forss (Petri Salmela)</li>



<li>Nightingale (e. Ready Cash) – Ulf Ohlsson (Roger Walmann)</li>



<li>Exposed Sox (e. Face Time Bourbon) – Tomas Pettersson</li>



<li>Knickers Sisu (e. Southwind Frank) – Mats E Djuse (Mattias Djuse)</li>



<li>Kinglet Bird (e. Nuncio) – Örjan Kihlström (Daniel Redén)</li>



<li>Larah Westwood (e. The Bank) – Magnus A Djuse (Mattias Djuse)</li>



<li>Laiza Westwood (e. Uncle Lasse) – Per Lennartsson (Mattias Djuse)</li>



<li>Willa Explosive (e. Explosive Matter) – Erik Adielsson (Johan Untersteiner)</li>



<li>Loke Sancy Diamond (e. Raja Mirchi) – Claes Sjöström (Roger Walmann)</li>
</ol>



<p class="has-text-align-center wp-block-paragraph">***</p>



<p class="has-drop-cap wp-block-paragraph">6Nästa lördag avgörs uttagningslopp till Derby del Trotto i Rom och den 41 hästar långa anmälningslistan innehåller som väntat Alessandro Gocciadoros E3-vinnare <strong>Expo Wise As </strong>(e. Ready Cash). Däremot finns det inga svensktränade hästar med i kvalen om man nu inte inkluderar Gocciadoro som har såväl italiensk som svensk proffslicens.</p>



<figure class="wp-block-image alignright size-full"><img src="https://sulkysport.se/wp-content/uploads/2023/07/expowiseaskrans230701adamstromstalltz-scaled.jpg" alt="" class="wp-image-465418"/><figcaption class="wp-element-caption">Expo Wise As jagar finalplats i italienska derbyt nästa lördag. Foto: Adam Ström/StallTZ.se.</figcaption></figure>



<p class="wp-block-paragraph">Någon start i varken Derby del Trotto eller Oaks blir det heller för Paul Hagoorts stostjärna <strong>Ester Degli Dei </strong>(e. Maharajah) som istället startar i ett försökslopp till Breeders Crown på Jägersro nu på onsdag.</p>



<p class="wp-block-paragraph">Startlistorna till derbykvalen blir klara på måndag och finalen avgörs likaså i Rom lördag den 8 oktober med en samlad prispott på 800.800 euro.</p>



<p class="has-text-align-center wp-block-paragraph">***</p>



<p class="has-drop-cap wp-block-paragraph">7Bjerke arrangerar tävlingar i dagarna tre. Under helgen avgörs Klasselöpsfinalerna och idag är det mer inriktat på vardagslopp samt ett antal unghästlopp.</p>



<p class="wp-block-paragraph">En noterbar deltagare syns i det inledande treåringsloppet då Jan Kristian Waalers <strong>Bollinger</strong> (e. Father Patrick) jagar revansch efter att misslyckats med att ta sig till final i Norskt Travkriterium.<br>Treåringen började sin karriär med att sluta tvåa i storloppet Hans Petter Tholfsens Minneslopp och var även trea i Prinsessan Märtha Louise Pokallöp, men hamnade i trötta ryggar sitt Kriteriekval och gick i mål med rubbet sparat.</p>

Fokustema
Morgonsvepet
Läs senare
E3-toppar i favoritjakt
Om kuskmatchen som stöpts om till ett stayerlopp, treåringstoppar som gör upp i nya Höstfavoriten och ett obesegrat löfte som lunchar på Färjestad går bland annat att läsa i dagens morgonsvep.
