
<p class="has-drop-cap wp-block-paragraph">1Inte mindre än fyra hästar har vunnit den korta E3-finalen för hingstar och valacker på 1.10,9. <strong>Standout</strong> var först ut 2012 och har därefter följts av <strong>Heavy Sound </strong>(2015), <strong>Aetos Kronos </strong>(2019) och fjolårsvinnaren <strong>Following</strong> på samma tidsnotering.<br>För fjärde gången i E3:s historia är förstapriset i den korta upplagan en miljon kronor, men nytt för i år är de slopade försöksloppen.<br>Istället har de tio deltagarna tagits ut via startpoäng och de övriga som visat intresse för dagens E3-tävlingar har förpassats till E3 Chansen där såväl klasserna för hingstar och valacker som ston samlat så pass stort intresse att det körs två ”tröstlopp” i vardera klass med 225.000 kronor till vinnaren.</p>



<p class="wp-block-paragraph">Sedan 2010 har tre hästar vunnit såväl den långa som korta upplagan av hingstarnas klass varav <strong>Felix Orlando</strong> (e. Orlando Vici) var den senaste att lyckas med den bedriften år 2021.<br>I år är det Alessandro Gocciadoros<strong> Expo Wise As</strong> (e. Ready Cash) som har chansen att lyckas upprepa den bedriften och i stoklassen ges <strong>Coral Coger </strong>(e. Ken Warkentin) samma chans.<br>Ola Åsebös sto drog dock nitlotten i spårtombolan och inleder dagens lopp från ett åttondespår bakom bilen.</p>



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



<p class="has-drop-cap wp-block-paragraph">2Det finns många lovande treåringar som inte fick plats i dagens E3-finaler som alltså istället är förpassade till E3 Chansen. De fyra loppen utgör V4-spelet innan V75:an tar vid och redan i det första loppet möts <strong>Flotilla</strong> (e. Readly Express) samt <strong>You To Class </strong>(e. Classic Photo) som båda var finalister i långa E3-finalen för hingstar och valacker.<br>I stonas E3 Chansen-lopp syns fem finalister från långa upplagan. Björn Goops <strong>Elegance Kronos</strong> (e. Muscle Hill) och Petri Salmelas <strong>Käraste Sisu</strong> (e. Face Time Bourbon) möts i det första E3 Chansen-loppet för ston och Alessandro Gocciadoros <strong>Esperia Font </strong>(e. Face Time Bourbon), Jerry Riordans <strong>Elisabeth Bar </strong>(e. Face Time Bourbon) samt Svante Båths <strong>Karma Mearas</strong> (e. Face Time Bourbon) går en match mot varandra i det andra loppet.<br>Det kryddas därtill med Hannu-Pekka Korpi-tränade <strong>Icella</strong> (e. Maharajah) som vann Tammahambo (€22.000) i Lahti i juli och som står med sex segrar på nio starter.</p>



<p class="wp-block-paragraph"><a rel="noreferrer noopener" href="https://sulkysport.se/wp-content/uploads/2023/08/19v75.pdf" target="_blank">Här kan du ta del av startlistor till tävlingarna på Romme.</a></p>



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



<p class="has-drop-cap wp-block-paragraph">3Utöver E3-loppen avgörs vanliga STL-klasser på Romme (första start kl. 14.45). I Gulddivisionsloppet Super Lights lopp jagar Fredrik B Larssons <strong>Milliondollarrhyme</strong> (e. Ready Cash) sin tredje inteckning i loppet efter att vunnit såväl år 2020 som 2021.</p>



<figure class="wp-block-image aligncenter size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/06/charmantdezackagm230621adamstromstalltz-617x399.jpg" alt="" class="wp-image-461198"/><figcaption class="wp-element-caption">Charmant de Zack ska tävla i Gulddivisionen. Foto: Adam Ström/StallTZ.se.</figcaption></figure>



<p class="wp-block-paragraph">Konkurrens saknas på intet vis med toppnamn som <strong>Global Badman</strong> (e. Yield Boko), <strong>Charmant de Zack</strong> (e. Vivid Wise As) och <strong>Mister Hercules</strong> (e. Trixton) i utmanarskaran.<br>I Silverdivisionen har Alessandro Gocciadoro valt att matcha sitt fyraåriga toppsto <strong>Don’t Say Gar </strong>(e. Varenne) mot äldre hästar tillika hingstar och valacker.</p>



<p class="wp-block-paragraph">Stoet blir klar favorit i sitt lopp och hur vi ställer oss till det i våra tips kan du läsa mer om här.</p>



<p class="wp-block-paragraph"><em>Vill du spela V75 tillsammans med Sulkysport finns följande alternativ:</em></p>



<p class="wp-block-paragraph"><a href="https://www.atg.se/andelskungen/spel/206687_V75_2023-08-19_23_5" target="_blank" rel="noreferrer noopener">Sulkysport Lilla V75 – 15 andelar á 75 kr/styck</a></p>



<p class="wp-block-paragraph"><a href="https://www.atg.se/andelskungen/spel/206688_V75_2023-08-19_23_5" target="_blank" rel="noreferrer noopener">Sulkysport V75 – 15 andelar á 150 kr/styck</a></p>



<p class="wp-block-paragraph"><a rel="noreferrer noopener" href="https://www.atg.se/andelskungen/spel/206689_V75_2023-08-19_23_5" target="_blank">Sulkysport Stora V75 – 15 andelar á 250 kr/styck</a></p>



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



<p class="has-drop-cap wp-block-paragraph">4När de finska V75-tävlingarna avgörs i Torneå drygt 13 mil från Boden är det många svensklicenserade aktörer som gör resan över gränsen.<br>Huvudloppet är det kombinerade fyra- och femåringsloppet Midnight Race och där finns tre Bodentränare representerade.<br>Sandra Eriksson startar sin färske Silverdivisionsvinnare <strong>Devils Tongue</strong> (e. Zola Boko), Hanna Olofsson bidrar med såväl<strong> Last Dying Breath</strong> (e. Nuncio) som <strong>The Oak L.A.</strong> (e. The Bank) och Petri Salmela med <strong>Juan Sisu</strong> (e. Canepa Hanover).<br>Salmela startar även <strong>Hector Sisu </strong>(e. Zola Boko) och <strong>Got To Dash</strong> (e. Ken Warkentin) i Gulddivisionen vilken även innehåller Sandra Erikssons <strong>Gazoline Mearas</strong> (e. Ready Cash) och Catarina Norqvists pånyttfödde elvaåring<strong> From the Mine</strong> (e. From Above).<br>Faktum är att ingen av de elva deltagarna i guldloppet är finskfödd utan fältet utgörs av nio svenskfödda, en amerikansk och en kanadensisk travare.</p>



<p class="wp-block-paragraph"><a href="https://heppa.hippos.fi/heppa/app?ct=YXBwbGljYXRpb24vcGRm&#038;d=dHJ1ZQ%3D%3D&#038;dr=&#038;f=b2hqZWxtYXRpZWRvdC5UT18xOS4wOC4yMDIzLnBkZg%3D%3D&#038;m=S%2F%2FtZOh1qc%2Fh0nlIfO%2B2XEi53Eg%3D&#038;r=MTY5MjIxNDM3MzQyNA%3D%3D&#038;service=pdftmp" target="_blank" rel="noreferrer noopener">Här kan du ta del av dagens startlistor till tävlingarna i Torneå.</a></p>



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



<p class="has-drop-cap wp-block-paragraph">5Idag avgörs det tyska Stoderbyt (€108.546) i Berlin (första start kl 12.00) och det sker blott med ett svenskt inslag.<br>Jägersrolicenserade Markus Waldmüller får chansen som kusk bakom Wolfgang Nimczyk-tränade <strong>Rushida</strong> (e. Maharajah) som inleder från spår elva efter att slutat trea i sitt försökslopp.</p>



<p class="wp-block-paragraph"><strong>Startlista Stuten-Derby</strong><br><em>1.900 meter autostart, förstapris: 51.773 euro</em></p>



<ol class="wp-block-list">
<li>IT Security (e. E L Titan) – Jochen Holzschuh</li>



<li>Bella Bavaria (e. Gustav Diamant) – Robin Bakker (Paul Hagoort)</li>



<li>Sevilla As (e. Father Patrick) – Michael Nimczyk (Wolfgang Nimczyk)</li>



<li>Marvellous Steel (e. Muscle Mass) – Dion Tesselaar</li>



<li>Mose Eagle (e. Bold Eagle) – Micha Brouwer (Paul Hagoort)</li>



<li>Yoko Ono Diamant (e. Tobin Kronos) – Jeffrey Mieras (Dion Tesselaar)</li>



<li>Sinfonie (e. Muscle Hill) – Josef Franzl</li>



<li>Mirone TS (e. Jimmy William) – Niels Jongejans (Didier Kokkes)</li>



<li>Samba Pa Ti (e. Broadway Hall) – Dennis Spangenberg (Andreas Gläser)</li>



<li>My Girl (e. Oropuro Bar) – Robin Bot (Johnny Westenbrink)</li>



<li>Rushida (e. Maharajah) – Markus Waldmüller (Wolfgang Nimczyk)</li>



<li>Eluise (e. Ganymede) – Rudolf Haller (Wolfgang Nimczyk)</li>
</ol>



<p class="wp-block-paragraph">Under tävlingsdagen avgörs även finalen av Super Trot Cup (€70.000). Christoffer Erikssons ger Micha Brouwer chansen bakom <strong>Grappa Boy</strong> (e. Djali Boko) och Marcus Lindgren lånar ut <strong>Nugget Zon </strong>(e. From Above) till Jörgen Sjunnesson. Johan Untersteiner tävlar i sin tur med <strong>Sierra S.</strong> (e. Father Patrick) i Auktionsrennen (€40.000) och har därtill <strong>Lauria Inferior S.</strong> (e. Muscle Hill) i Consolation av Stoderbyt (€10.000).</p>



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



<p class="has-drop-cap wp-block-paragraph">6Efter att haft tävlingsledigt sedan slutet av juni tävlas det i dag åter på den franska nationalarenan Vincennes (första start kl. 13.40).<br>De inleder dunder och brak då inte mindre än sex Grupp-lopp ska avgöras under eftermiddagen och fem av dem är kvalificerande till Criterium-loppen för tre, fyra- och femåringar som avgörs den 17 september.</p>



<p class="wp-block-paragraph">Thierry Duvaldestin startar sin toppfemåring <strong>Idao de Tillard</strong> (e. Severino) i Prix Louis Jariel (€120.000) och Jean-Michel Bazire startar sin toppfyraåring <strong>Jushua Tree </strong>(e. Bold Eagle) i Prix Phaeton (€120.000). Två lopp som avgörs helt utan svenska inslag.</p>



<p class="wp-block-paragraph">Tomas Malmqvist har dock fyra chanser i andra lopp. I Prix Reine du Corta (€120.000) för treåriga ston startar han såväl<strong> Kacha de Vandel </strong>(e. Pacha du Pont) som <strong>Killer Queen </strong>(e. Face Time Bourbon) och jämngamle <strong>Kronos du Klau</strong> (e. Django Riff) prövar lyckan i hingstarnas klass Prix Abel Bassigny (€120.000).</p>



<p class="wp-block-paragraph"><strong>Jazzy Perrine</strong> (e. Django Riff) som vann Fyraåringseliten för ston på 1.09,0 under Elitloppsdagen startar därtill i Prix Paul Leguerney (€120.000) och så har Malmqvist med <strong>Intuition</strong> (e. Brillantissime) i Prix Legoux-Longpre (€85.000) för fyra- och femåriga sadelhästar.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/trav-och-galopp/paris-vincennes-2023-08-19/" target="_blank" rel="noreferrer noopener">Här kan du ta del av dagens startlistor till tävlingarna på Vincennes.</a></p>



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



<p class="has-drop-cap wp-block-paragraph">7 Pocono Downs bjuder på högklassiga tävlingar ikväll med tvåan och trean i Hambletonian, Marcus Melanders <strong>Oh Well</strong> (e. Muscle Hill) respektive Åke Svanstedts <strong>Up Your Deo</strong> (e. Walner). Duon startar i den högsta divisionen av Earl Beal Jr Memorial ($300.000), som sedan några år tillbaka inte avgörs med försök och final utan är uppdelat i tre divisioner med 300.000, 200.000 respektive 100.000 dollar i potten.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/08/ohwellmmmh230802adamstromstalltz-1-617x399.jpg" alt="" class="wp-image-479409"/><figcaption class="wp-element-caption">Marcus Melanders Oh Well startar i Earl Beal Jr. Memorial ikväll. Foto: Adam Ström/stalltz.se</figcaption></figure>



<p class="wp-block-paragraph">Åke Svanstedt har två segrar i loppet tidigare med <strong>Marseille </strong>(e. Muscle Hill) 2019 respektive <strong>Captain Corey </strong>(e. Googoo Gaagaa) 2021. Ifjol vann Marcus Melanders <strong>Temporal Hanover </strong>(e. Walner). </p>



<p class="wp-block-paragraph">Värst av svenskarna i loppet som körts sedan 2011 är Jimmy Takter med tre triumfer; <strong>Corky</strong> (e. Muscles Yankee) 2013, <strong>Father Patrick </strong>(e. Cantab Hall) 2014 och <strong>Pinkman</strong> (e. Explosive Matter) 2015.</p>



<p class="wp-block-paragraph">På Pocono Downs möts också ettan och tvåan i Hambletionian Oaks, Marcus Melanders <strong>Heaven Hanover</strong> (e. Father Patrick) och Åke Svanstedts <strong>Bond</strong> (e. Southwind Frank). Det handlar om Delmonica Hanover ($250.000) för treåriga ston och det loppet har också tre divisioner med 75.000, 125.000 och 250.000 dollar i prissumma.</p>



<p class="wp-block-paragraph"><a href="https://racing.ustrotting.com/goto.aspx?target=12,91266" target="_blank" rel="noreferrer noopener">Startlistorna hittar ni här.</a></p>

Fokustema
Morgonsvepet
Läs senare
1.10,9 – tiden att slå
Om dagens E3-tävlingar på Romme, den stora mängd svenskar som prövar lyckan inom V75-tävlingarna i finska Torneå och om den tyska Stoderbyfinalen kan du bland annat läsa i helgens första morgonsvep.
