
<p class="has-drop-cap">1 Efter lite trassel under försommaren har Ulrika Wällstedts startkatapult <strong>Sourire Frö</strong> (e. Wishing Stone) kommit tillbaka på fint sätt i sommar med dubbla segrar och lika många pallplatser (bakom Francesco Zet respektive Borups Victory). Däremot räckte inte nästan 3.000 startpoäng för att komma med i Margareta Wallenius-Klebergs Pokal på Solvalla för två veckor sedan och Wällstedt har fått leta andra uppgifter.</p>



<p>Ikväll i <strong>Örebro</strong> (start 18.20) väntar en spårtrappa över medeldistans och ett möte med meriterade travare som forne Elitloppshästen <strong>Seismic Wave</strong> (e. Explosive Matter) och <strong>Phoenix Photo</strong> (e. Super Photo Kosmos), som vann gulddivisionslopp i Eskilstuna i juli.</p>



<p>Sex segrar på åtta starter men bara 45.000 kronor i prissumma var resultatet för österrikaren <strong>Onyx A.T. </strong>(e. Equinox Bi) förra året. Sedan i vintras finns hästen i Björn Goops stall där debuten slutade med seger. Nu jagar han en ny seger när Peter Zadel hoppar upp i sulkyn.</p>



<p>Det är jackpot i kvällens V64-omgång med drygt 800.000 kronor extra i sexrättspotten.</p>



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



<p class="has-drop-cap">2 Tomas Pettersson har ett löfte i treårige<strong> From the Hip</strong> (e. Readly Express), som på tre starter vunnit två lopp på 1.15-tider, men galopperat bort sig i den tredje. Nu jagar han en ny seger i ett treåringslopp på hemmabanan <strong>Bollnäs</strong> (start 17.45).</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2021/06/tomaspettersson-617x333.jpg" alt="" class="wp-image-175677"/><figcaption class="wp-element-caption">Tomas Pettersson tränar From the Hip. Foto Mathias Hedlund/Sulkysport.se</figcaption></figure>



<p>Där bjuds också ett flerklasslopp för högsta kallblodsklassen med fjolårets Derbyfinalist <strong>Dellenit (</strong>e. B.W.Modde) på startfållan, Jan-Olov Perssons nyförvärv<strong> Ard</strong> (e. Moe Odin) – tvåa i JOP-debuten på Romme – från 20 meters tillägg och forne Derbyvinnaren <strong>Philip Ess </strong>(e. Briskeby Philip) jagande från dubbla tillägg.</p>



<p>Lunchtävlingarna avgörs i <strong>Visby</strong> (start 12.20) och Gävletränaren Oskar Kylin Blom fyller hästbussen med sex hästar. Det finns gott om segerchanser på förhand, bland annat är dubbelmiljonären <strong>Ubiquarian Face </strong>(e. Joke Face) tillbaka efter kortare uppehåll då han tvingades styrkas från den tilltänkta gulddivisionsstarten på Hagmyren för en månad sedan.</p>



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



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



<p class="has-drop-cap">3 Nio hästar av tio är nu klara för VM-loppet och igår bjöds Ron Burkes stjärna <strong>It’s Academic</strong> (e. Uncle Peter-Annapolis), 1.08,5*/$1.863.434, in och precis som Marcus Melanders Venerate startar han i <a href="https://sulkysport.se/venerate-inbjuden-till-vm/" target="_blank" rel="noreferrer noopener">Maple Leaf Trot </a>(C$530.000) på Mohawk Raceway.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/08/itsacademic081223casalinovaphotoscaled-617x441.jpg" alt="" class="wp-image-482489"/><figcaption class="wp-element-caption">It&#8217;s Academic vid sin femte raka seger på Northfield Park.</figcaption></figure>



<p>It’s Academic har haft en mycket stark säsong och står med fem raka segrar. Närmast kommer han från vinst i Tom Aldrich President’s Trot ($100.000) och innan dess har det blivit triumfer i John Cashman Memorial ($278.000) och nämnas kan också The Spirit of Massachusetts ($250.000) och Crawford Farms ($155.140).</p>



<p>En häst till ska bjudas in till VM-loppet och det lär – enligt Yonkers Raceway – bli en häst från Kanada.</p>



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



<p class="has-drop-cap">4 I tisdags kvalade australiensaren och VM-deltagaren <a rel="noreferrer noopener" href="https://sulkysport.se/australiensare-klar-for-vm/" target="_blank">Aldebaran Zeus</a> (e. Muscle Hill-Zoia Boko e. Viking Kronos) på Harrah’s Philadelphia i Chester för Bradley Chisholm på 1.10,7/1.609 meter. Han var dock avhängd med sju längder av <strong>Pappardelle</strong> (er. Wishing Stone-Long Island Tea) och Joe Bongiorno, vilken noterade 1.09,9 över den engelska milen.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/03/r3aldebaranzeustbrentlilleydchrisalford11-617x411.jpg" alt="" class="wp-image-416060"/><figcaption class="wp-element-caption">Aldebaran Zeus vid en tidigare seger för Chris Alford. Foto: Menangle</figcaption></figure>



<p>Sexårige Aldebaran Zeus, 1.10,0*/$419.142, har vunnit 18 lopp på 48 starter och blir Australiens representant i Yonkers International/VM-loppet ($1.000.000) på Yonkers Raceway den 9 september.</p>



<p><a href="https://sulkysport.se/venerate-inbjuden-till-vm/" target="_blank" rel="noreferrer noopener">Här hittar du hästarna som bjudits in till loppet.</a></p>



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



<p class="has-drop-cap">5 Två svenskfödda travare dyker upp i Cesena på lördag och då handlar det om heatloppet Campionato Europeo (€154.000) och tolv hästar har anmälts till löpningen, som kan bli en uppgörelse i tre akter om det blir olika vinnare i respektive heat och där startordningen blir den omvända i andra heatet. Från svenskt håll handlar det om <strong>Global Trustworthy</strong> (e. Muscle Hill) och <strong>Zola Key</strong> (e. Zola Boko).</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/08/corsa8finalegranpremiocittadimontecatiniarrivovernissagegrif-617x411.jpg" alt="" class="wp-image-484314"/><figcaption class="wp-element-caption">Vernissage Grif vinner finalen i Gran Premio Citta di Montecatini. Foto: Ippodromo Montecatini</figcaption></figure>



<p>Hälften av de startande tränas av Alessandro Gocciadoro och han väljer själv att köra <strong>Vernissage Grif </strong>(e. Varenne), vilken närmast kommer från försök- och finalseger i Grupp I-loppet Gran Premio Citta di Montecatini (€100.980) i Montecatini.</p>



<h2 class="wp-block-heading">Startlista:</h2>



<p><strong>Campionato Europeo </strong>(€154.000)<br>Äldre travare.<br><em>1.660 meter, autostart</em></p>



<p><strong>Namn – Körsven – Spår i andra heatet ()</strong></p>



<ol class="wp-block-list">
<li><strong>Zola Key </strong>– Sandro Miraglia (12)</li>



<li><strong>City Lux </strong>– Riccardo Peaaztini (11)</li>



<li><strong>Bonneville Gifont</strong> – Antonio Simioli (10)</li>



<li><strong>Vernissage Grif </strong>– Alessandro Gocciadoro (9)</li>



<li><strong>Vesna</strong> – Rene’ Legati (8)</li>



<li><strong>Verdon Wf </strong>– Giampaolo Minnucci (7)</li>



<li><strong>Global Trustworthy </strong>– Santo Mollo (6)</li>



<li><strong>Zacon Gio</strong> – Vincenzo P Dell’Annunziata (5)</li>



<li><strong>Achille Blv</strong> – Ernico Bellei (4)</li>



<li><strong>Vincero’ Gar </strong>– Pietro Gubellini (3)</li>



<li><strong>Sunny Crockett</strong> – Antonio Greppi (2)</li>



<li><strong>Akela Pal Ferm </strong>– Antonio di Nardo (1)</li>
</ol>



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



<p class="has-drop-cap">6 Mer italienskt är det på söndag och då bjuds det på Grupp I-loppet Gran Premio Carlo Marangoni (€154.000) för treåringar i Turin. Ett sto tar chansen – <strong>East Asia</strong> (e. Ready Cash) – i det penningstinna loppet.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2022/12/skarmavbild20221208kl.15.57.46-617x374.jpg" alt="" class="wp-image-390078"/><figcaption class="wp-element-caption">East Asia vinner Gran Premio Mipaaf  för Andrea Farolfi ifjol Foto: Gerard Forni</figcaption></figure>



<p>Tidigare i år har Mauro Baroncini-tränade East Asia hävdat sig mot hingstarna och bland annat vunnit Grupp I-klassade Gran Premio Citta di Napoli (€154.000) i Neapel.</p>



<h2 class="wp-block-heading">Startlista: </h2>



<p><strong>Gran Premio Carlo Marangoni </strong>(€154.000)<br>Treåringar.<br><em>2.100 meter, autostart.</em></p>



<p><strong>Namn (far) – Körsven</strong></p>



<ol class="wp-block-list">
<li><strong>Elton Wise </strong>(e. Maharajah) – Alessandro Gocciadoro</li>



<li><strong>Eminem Font</strong> (e. Ringostarr Treb) – Marco Stefani</li>



<li><strong>Edy Girifalco Gio</strong> (e. Victor Gio) – Santo Mollo</li>



<li><strong>Ector Francis</strong> (e. Nad al Sheba) – Gaetano di Nardo</li>



<li><strong>Ebano d’Arc</strong> (e. Bird Parker) – Alexandre Abrivard</li>



<li><strong>East Asia</strong> (e. Ready Cash) – Andrea Farolfi</li>



<li><strong>Energy King Gar</strong> (e. Wishing Stone) – Antonio di Nardo</li>



<li><strong>Excelsior </strong>(e. Wishing Stone) – Lorenzo Baldi</li>



<li><strong>Ehlert Pa</strong>r (e. Ruty Grif) – Francesco Facci</li>



<li><strong>Eolo Jet </strong>(e. Wishing Stone) – Massimiliano Castaldo</li>



<li><strong>Encierro </strong>(e. Tobin Kronos) – Gaspare Lo Verde</li>



<li><strong>Ettore Trebi’ </strong>(e. Nad al Sheba) – Andrea Guzzinati</li>



<li><strong>Encantador Laksmy</strong> (e. Bold Eagle) – Pietro Gubellini</li>
</ol>



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



<p class="has-drop-cap">7 Svenskintresse går att skönja när det tävlas i <strong>Marseille Borely</strong> (första start kl. 11.30) denna torsdag. I det åttonde och sista loppet för dagen namngivet Prix du Mugel (€27.000) debuterar Elinor Lindbergs <strong>I Can Steel</strong> (e. Maharajah) på fransk mark med Bryan Coppens som kusk.</p>



<p>Den tyskfödde valacken har inte vunnit lopp på elva månader och möter bland annat svenskfödda duon <strong>Dante Godiva</strong> (e. Up And Quick) samt <strong>Deep Pockets</strong> (e. Ready Cash) i dagens lopp, vilka båda tränas av David Cinier.</p>
