
<p class="has-drop-cap wp-block-paragraph">1Fredagens högst doterade lopp på svensk mark är E3-revanschen i Kalmar (första start 18.20). Blott sex hästar känner sig dock kallade i kamp om förstapriset på 150.000 kronor. Kvaliteten är det dock inget fel på med Breeders Crown-femman<strong> Fashion Monger</strong> (e. Panne de Moteur) och Kriterieförsöksvinnaren <strong>Pantocrator</strong> (e. Quarcio du Chene) i spetsen.</p>



<p class="wp-block-paragraph">Kvällens E3-revansch är den andra av fyra och de övriga två avgörs i Örebro 18 december (öppen klass, 1.609 meter auto) och i Gävle (ston, 2.140 meter auto).</p>



<p class="wp-block-paragraph">Nästa års E3-finaler avgörs på Färjestad den 29 juni (medeldistans) och i Gävle den 17 augusti (kort distans). </p>



<p class="wp-block-paragraph">I övrigt i Kalmar då? Goda travare som <strong>Larry Wood</strong> (e. Maharajah), <strong>Mr Mah Can</strong> (e. Maharajah) och <strong>Nina Ginto </strong>(e. Yarrah Boko) har inte fått till det på sistone och startpoången har trytit. Det kan trion dra nytta av i ett lopp som egentligen är stängt vid 1,1 miljoner kronor, men hästar med mindre än 500 startpoäng får ha tjänat upp till två miljoner. I den kategorin passar ovanstående hästar in.</p>



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



<p class="has-drop-cap wp-block-paragraph">2Kalmar och Boden (start 18.30) delar kvällens expresstrav med V64 och på landets nordligaste bana plockar hemmatränaren Petri Salmela ut fyraårige segermaskinen <strong>Jamie Sisu</strong> (e. Nuncio), som startar från spår tolv i en fylld spårtrappa med 15 hästar.</p>



<p class="wp-block-paragraph">Jamie Sisu debuterade först i slutet av november ifjol som treåring, men hann med två segrar före nyår. I år har han fortsatt plocka vinster (sex på tio starter) och nu ståtar han med fyra raka i resultatraden efter att bland annat ha vunnit klass II-försöket inom V75 på hemmaplan i oktober.</p>



<p class="wp-block-paragraph">Den segern säkrade plats i STL-finalerna på Solvalla och det återstår att se om Jamie Sisu får resa långt för att tävla där. Hittills har han gjort alla starter utom en i Boden och det tolfte tävlingsframträdandet skedde i Skellefteå.</p>



<p class="wp-block-paragraph">En som både är van att resa långt och tävla i tuff konkurrens är Madelene Wikstén-tränade <strong>Maybach W.F. </strong>(e. Maharajah). Med start med segern i bronsdivisionsförsöket på Umåker i maj så har Maybach W.F. enbart tävlat i STL-sammanhang. Med 0-6-6 som resultat i de tre senaste starterna går han. ikväll ned i klass rejält till ett ”vanligt” lopp, där Sandra Erikssons <strong>Devils Tongue</strong> (e. Zola Boko) jagar 20 meter bakom från start.</p>



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



<p class="has-drop-cap wp-block-paragraph">3Bergsåkertränaren Henrik Svensson har ett toppår som kusk, där han vunnit 69 lopp och kört in över sex miljoner kronor. Som tränare snuddar han vid fjolårets 27 segrar och bakom sex av dessa står kallblodet <strong>Ava Modde</strong> (e. B.W.Modde).</p>



<p class="wp-block-paragraph">Denne visade fina takter som treåring (tre segrar på sex starter), men sedan väntade 1,5 års tävlingsuppehåll. I år har han kommit tillbaka med stormsteg och inte varit sämre än trea på säsongens tio starter. Han fick dock sin fem vinster långa triumfrad bruten i senaste starten, men idag kan börja en ny när Bollnäs (första start 12.20) har hand om lunchtävlingarna.</p>



<p class="wp-block-paragraph">Tuffaste utmanaren startar 20 meter framför och är en annan segervan valack. Åbytränaren Peter Grundmanns sexåring <strong>Basisten</strong> (e. Horgen Tore) finns sedan i höstas hos Jan Ove Olsen, där han varit etta-tvåa i två starter efter långt uppehåll.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2023/12/231208.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">4Det körs fem travlopp med sexsiffrigt förstapris på svensk mark nu på onsdag då Jägersro och Solvalla arrangerar kvällstävlingar och delar på V86-värdskapet.</p>



<p class="wp-block-paragraph">I huvudstaden handlar det om Nordindagen, men såväl fyraåringsloppet Gunnar Nordins lopp som snabbloppsklassade Gösta Nordins lopp har placerats utanför V86-spelet då loppen blott innehåller fem respektive åtta deltagare.<br>Sören Nordins lopp för treåringar har däremot nio tävlande och tar plats på det stora streckspelet.</p>



<figure class="wp-block-image aligncenter size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/11/luliusbokobgh231122adamstromstalltz-617x376.jpg" alt="" class="wp-image-526166"/><figcaption class="wp-element-caption">Lulius Boko vid kvalet på Solvalla i lag med Björn Goop. Foto: Adam Ström/stalltz.se</figcaption></figure>



<p class="wp-block-paragraph">I Gösta Nordins lopp finner vi likväl tävlingsdagens mest intressanta häst. Efter 15 månaders tävlingsfrånvaro är äntligen Timo Nurmos-tränade<strong> Lulius Boko</strong> (e. Muscle Hill) redo att göra sin första start sedan andraplatsen i fjolårets final av Svenskt Travderby.<br>Den 22 november kvalade hästen på 1.15,1/2.140 meter i lag med Björn Goop som även kör i onsdagens lopp.</p>



<p class="wp-block-paragraph">I Malmö körs årets fjärde och sista Breeders Crown-lopp för tvååringar och där gör bland annat tvåan från Dansk Uppfödningslöpning <strong>Koningin</strong> (e. Great Challenger) ett intressant gästspel.</p>



<p class="wp-block-paragraph"><a rel="noreferrer noopener" href="https://sulkysport.se/wp-content/uploads/2023/12/13v86.pdf" target="_blank">Här kan du ta del av onsdagens startlistor till tävlingarna på Jägersro och Solvalla.</a></p>



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



<p class="has-drop-cap wp-block-paragraph">5Danskfödda <strong>Eenymeenyminymoe</strong> (e. Västerbo Prestige) 1.10,8ak/1.540.325 ddk vann Stoeliten i Halmstad i mars, men har haft en sämre period därefter med elva starter i följd utan seger.</p>



<p class="wp-block-paragraph">Nu har det sjuåriga stoet bytt regi och manageras numera av Jean-Michel Bazire på fransk mark som sedan tidigare även fått<strong> Eros Zola</strong> (e. Zola Boko) i träning från Eenymeenyminymoes ex-tränare Flemming Jensen.<br>På stoets cv finns även triumf i Stoderbyt från fyraåringssäsongen.</p>



<p class="wp-block-paragraph"><strong>Såhär gick det för gårdagens svenskhopp på Vincennes:</strong></p>



<p class="wp-block-paragraph"><em>Hästnamn (far) – Tränare – Placering – Prispengar</em></p>



<ul class="wp-block-list">
<li><strong>Glamorous Rain</strong> (e. Muscle Hill) – Daniel Redén – vinnare – 40.500 euro</li>



<li><strong>Great Skills</strong> (e. Ready Cash) – Daniel Wäjersten – tvåa – 22.500 euro</li>



<li><strong>Galiano du Bocage</strong> (e. Singalo) – Ron Kuiper – trea – 2.520 euro</li>



<li><strong>Sayonara</strong> (e. Donato Hanover) – Fredrik Wallin – fyra – 7.200 euro</li>



<li><strong>Kezio Josselyn </strong>(e. Love You) – Björn Goop – fyra – 2.800 euro</li>



<li><strong>Self Explosive</strong> (e. Explosive Matter) – Christoffer Eriksson – sexa – 1.500 euro</li>



<li><strong>Istra</strong> (e. Ulysse) – Rikard Björling – oplacerad</li>



<li><strong>Lord</strong> (e. Earl Simon) – Jarmo Niskanen – diskvalificerad</li>
</ul>



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



<p class="has-drop-cap wp-block-paragraph">6På tal om tidigare nämnda Nordindagen så är det nu klart vem som har utsetts till årets Nordinstipendiat.</p>



<p class="wp-block-paragraph">Det blir 30-årige Niclas Hammarström som får mottaga priset och 10.000 kronor efter ett formidabelt år med 29 kusksegrar och 2.212.500 kronor i inkörda prispengar. Personliga rekordsiffror så det står härliga till!<br>– <em>Det känns lite overkligt. Jag läste Sören Nordins bok för tiotalet år sedan och bär fortfarande med mig kunskaper jag snappade upp där. Det här är så häftigt!. Jag kommer plocka ut proffstränarlicensen vid årsskiftet på Solvalla, så att de går till något bra inom min rörelse behöver ingen tveka på</em>, säger Niclas Hammarström i ett pressmeddelande.</p>



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



<p class="has-drop-cap wp-block-paragraph">7Stall Courant har valt att importera USA-födda <strong>Karaboudjan</strong> (e. Walner) 1.09,9ak/500.247 kr till Sverige och satt henne i träning hos Adrian Kolgjini.<br>Det egenuppfödda stoet står med två segrar på 13 starter och har bland annat varit finalist i Kentucky Sire Stakes Filly denna säsong i Marcus Melanders regi.</p>



<p class="wp-block-paragraph">I Sverige kvarstår Karaboudjan i såväl Drottning Silvias Pokal som Stosprintern.</p>



<p class="wp-block-paragraph">Ostartade modern <strong>Noblesse Blue Chip</strong> (e. Credit Winner) kvalade tre gånger för Ron Burke och som snabbast 1.20,0. Som ettåring kostade stoet 92.000 dollar och Anders Ström köpte henne året efter på Harrisburgs mixedauktion för 27.000 dollar.</p>



<p class="wp-block-paragraph">Noblesse Blue Chip är undan likaledes ostartade <strong>Reven Crown</strong> (e. Revenue), vilken lämnat <strong>Rolls Blue Chip</strong> ($279.763) och <strong>Quadratic Blue Chip</strong> ($205.355). Reven Crown är också halvsyster med Hambletonian-vinnaren <strong>Scarlet Knight </strong>(e. Pine Chip), 1.10,0ak*/17.860.273 kr, och <strong>Ruby Trap</strong> (e. Explosive Matter), 1.11,3ak/1.456.300 kr, som vann Drottning Silvias Pokal.</p>

Fokustema
Morgonsvepet
Läs senare
Revanschjakt i Småland
Om kvällens E3 Revansch i Kalmar, Stoeliten-vinnare till Jean-Michel Bazire och en derbytvåa som gör efterlängtad comeback går bland annat att läsa i fredagens morgonsvep.
