
<p class="has-drop-cap">1Solvalla (första start 18.15) och Åby (start 18.27) delar på kvällens expresstrav och på Åby dyker bland annat ett revanschsuget sto upp.</p>



<p>Johan Untersteiner-tränade <strong>Stens Retention</strong> (e. Raja Mirchi) avslutade treåringssäsongen ifjol på finfint sätt som tvåa i Breeders Crown-finalen i Eskilstuna och i våras kvalade hon in till Drottning Silvias Pokal (oplacerad i finalen).</p>



<p>Men när det var uttagningslopp till Derbystoet på Jägersro häromveckan fick Stens Retention släppa ledningen 950 meter från mål och blev med knapp marginal utslagen som trea.</p>



<p>Nu får hon sikta in sig på Breeders Crown i höst och vägen dit går bland annat via kvällens stolopp mot äldre hästar på Åby över sprinterdistans. Att Stens Retention kan trava snabbt visade hon i BC-försöket i Tingsryd, där hon slutade tvåa på 1.10,6ak.</p>



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



<p class="has-drop-cap">2På Solvalla är det dags för andra försöksomgången i årets nyhet Solvallaserien, vars fjärde meeting för året drog igång förra veckan. 80.000 kronor är förstaprisen i försöken, medan finalvinnarna i de tre klasserna plockar 150.000 kronor vardera.</p>



<p>Timo Nurmos-tränade <strong>Mellby Imperial </strong>(e. Readly Express) har redan vunnit försök i både lägsta klassen (högst 150.000 kr) och mellanklassen (högst 350.000 kr) när han ikväll kliver in i den högsta som är öppen för hästar med högst 650.000 kronor på kontot. </p>



<p>Tre av Solvallas fyra V86-lopp är just försök till Solvallaserien och finalerna avgörs på Solvalla den 4 oktober.</p>



<p><a href="https://sulkysport.se/wp-content/uploads/2023/08/30v86.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till onsdagens tävlingar.</a></p>



<p>Sulkysports spelstuga till V86 med viktiga punkter, spelförslag och favoriter i fara publiceras som vanligt kl 12.00 idag.</p>



<p><em>Vill du spela V86 tillsammans med Sulkysport kan du välja mellan följande alternativ:</em></p>



<p><a href="https://www.atg.se/andelskungen/spel/206233_V86_2023-08-30_40_1" target="_blank" rel="noreferrer noopener">Sulkysport Lilla V86 – 15 andelar á 75 kr/styck</a></p>



<p><a rel="noreferrer noopener" href="https://www.atg.se/andelskungen/spel/206235_V86_2023-08-30_40_1" target="_blank">Sulkysport Stora V86 – 15 andelar á 250 kr/styck</a></p>



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



<p class="has-drop-cap">3Försöken för tvååringar i löpningsserien Breeders Course drog igång i nederländska Wolvega i söndags, där <strong>Feldenkrais Pal </strong>(e. Trixton-Tuscania Pal) vann övertygande tillsammans med Micha Brouwer på 1.14,5a/1.609 meter.</p>



<p>Ikväll på Solvalla är det dags för det första uttagningsloppet på svensk mark, när sju tvååringar gör upp om tre finalplatser på Jägersro den 4 oktober med ett förstapris på 700.000 kronor. Kort distans och startbil är förutsättningarna som gäller.</p>



<p>I kvällens Solvallaförsök debuterar Per Nordström stoet <strong>Zipzeronada</strong>, som är helsyster till forne svenske Uppfödningsloppvinnaren <strong>Bythebook</strong> (e. Googoo Gaagaa-Stellar Value). En av deltagarna vet redan hur det känns att vinna lopp, norskfödde <strong>Gimmefive Ravin</strong> (e. Ken Warkentin). </p>



<p>Ytterligare två försök ska göra finalfältet komplett, på Åby den 6 september och på Jägersro en vecka senare.</p>



<p>Fjolårets tvååringsfinal vanns av <strong>Novato</strong> (e. Maharajah) och Dion Tesselaar.</p>



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



<p class="has-drop-cap">4Vincennes (första start kl. 11.55) travas igång sina onsdagsövningar redan under den tidiga lunchen.<br>Tomas Malmqvist bidrar med en duo och störst förväntningar lär ställas på <strong>Kostanostra</strong> (e. Express Jet) som startar i Prix de Chartres (€40.000) för treåriga ston.</p>



<figure class="wp-block-image alignright size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/01/tomasmalmqvistscoopdyga2-617x333.jpg" alt="" class="wp-image-402765"/><figcaption class="wp-element-caption">Tomas Malmqvist. Foto Scoopdyga.com</figcaption></figure>



<p>Eric Raffin kör stoet som jagar sin tredje raka seger medan Gabriele Gelormini svingar sig upp bakom Coktail Jet-sonen <strong>Junior du Vallon </strong>i Prix de Vimoutiers (€35.000) för fyraåriga hingstar och valacker.</p>



<p>Det travas därtill i Les Sables-d&#8217;Olonne (första start kl. 16.26) denna onsdag och där jagar Jarmo Niskanens <strong>Kai La Sha</strong> (e. Earl Simon) karriärens andra seger.<br>Treåringen kommer till start i Prix Edmond Gamare (€21.000) och körs av Joan Melis Macias.</p>



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



<p class="has-drop-cap">5 Dugliga prispengar i vardagstravet är något som finsk travsport sannerligen inte är bortskämda med, men under tisdagskvällen gjordes ett undantag.<br>Sprinter Champion i Björneborg avgjordes via försök och final och där kunde svenskbekante <strong>Piteraq</strong> (e. Muscle Hill) totalt kamma hem 12.000 euro efter att vunnit försöket på 1.12,2a/1.609 meter och finalen på 1.13,0a/1.609 meter.</p>



<p>Esa Holopainen styrde Juuso Holttinens sjuåring till vinst som vilken tävlade i Ville Karhulahtis regi fram tills mitten av fyraåringssäsongen.</p>



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



<p class="has-drop-cap">6Timo Nurmos kliver in i dagens tävlingar på Solvalla med stallformen på topp. De sju senaste hästarna som startat från stallet har nämligen vunnit lopp efter att Kendall Jackson (e. Uncle Lasse) vunnit Klass I på Bergsåker och man räknat hem en lunchtrippel i såväl Mantorp som på Romme i början av denna vecka.</p>



<p>Bland gårdagens segergods fanns den fyrårige Villiam-sonen <strong>Live To Tell </strong>som alltjämt är obesegrad fyra starter in i karriären efter att vunnit gårdagens lopp på nya rekordet 1.14,6a/2.140 meter.</p>



<figure class="wp-block-image aligncenter size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2022/09/timonurmoslangvagn-617x333.jpg" alt="" class="wp-image-357265"/><figcaption class="wp-element-caption">Timo Nurmos staplar segrar på hög. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



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



<p class="has-drop-cap">7Solvallalicenserade Mika Forss kommer att köra finalen av Finskt Travderby på Vermo.<br>Loppet avgörs i Helsingfors nu på lördag och Forss styrning är Jukka Hakkarainen-tränade <strong>Massimo Hoist </strong>(e. Muscle Hill) som inleder från spår sex efter att slutat tvåa i sitt uttagningslopp.<br>Forss får även chansen bakom Seinäjoki Race-fyran <strong>Shackhills Twister </strong>(e. Il Villaggio) i Finskt Mästerskap där det tävlas om 30.000 euro till vinnaren.</p>



<p><strong>Startlista Finskt Travderby</strong><br>2.620 meter autostart, förstapris: 120.000 euro</p>



<p><em>Startnummer – hästnamn (far) – kusk (tränare)</em></p>



<ol class="wp-block-list">
<li>Callela Nelson (e. Beer Summit) – Hannu Torvinen (Jukka Hakkarainen)</li>



<li>Laxvikens Amiral (e. Jontte Boy) – Tuomas Korvenoja</li>



<li>American Cooper (e. Maharajah) – Ari Moilanen (Markku Nieminen)</li>



<li>EL Kazaam (e. Love You) – Iikka Nurmonen (Elina Laakkonen)</li>



<li>Ava Di Alessia (e. Express Duo) – Antti Teivanen (Hannu-Pekka Korpi)</li>



<li>Massimo Hoist (e. Muscle Hill) – Mika Forss (Jukka Hakkarainen)</li>



<li>Halley Wania (e. EL Titan) – Santtu Raitala (Markku Nieminen)</li>



<li>Corazon Combo (e. Express Duo) – Pekka Korpi</li>



<li>Blackbeard (e. RC Royalty) – Jukka Torvinen (Tapio Lehtoranta)</li>



<li>Crepe Match (e. Creatine) – Olli Koivunen (Harri Koivunen)</li>



<li>Everlasting Boogie (e. Pastor Stephen) – Kenneth Danielsen</li>



<li>Callela Alfa (e. Classic Photo) – Tapio Perttunen</li>
</ol>

Fokustema
Morgonsvepet
Läs senare
Sjutusan vilken stallform!
Om Timo Nurmos hiskeliga stallform, en svensklicenserad kusk som kör lördagens Derbyfinal i Finland och nya Malmqvist-chanser i Frankrike går bland annat att läsa i dagens morgonsvep.
