
<p class="has-drop-cap wp-block-paragraph">1 Torsdagens tävlingar på svensk mark inleds med ett noterbart starkt fält som drabbar samman redan i det första lunchloppet i <strong>Bollnäs</strong> (första start kl. 12.20).<br>Hans R Strömbergs<strong> Xerava C.D. </strong>(e. Uncle Lasse) gör sin första start sedan finaldeltagandet i Stochampionatet och för första gången på 16 månader så kommer stoet till start som tränarkörd.<br>Tränarkörd är även High Coast Race-vinnaren <strong>Soul Tan</strong> (e. Maharajah) som travar ut i lag med Elisabeth Lundholm och de möter fyra hästar som kommer från V75-starter i form av<strong> Global Classifed</strong> (e. Bold Eagle), <strong>Mission Beach</strong> (e. The Best Madrik) samt <strong>Barry Wadd </strong>(e. Super Photo Kosmos) samt <strong>Imagine Boko</strong> (e. Kadabra).<br>Den sistnämnde gör comeback efter tio månaders tävlingsuppehåll då han slutade tvåa i Monté SM på Åby.</p>



<p class="wp-block-paragraph">I Bollnäs startar även Timo Nurmos två treåringar som redan hunnit visa framhovarna med segerlopp.<br><strong>Fniss</strong> (e. Villiam) vann sin tävlingsdebuten på Fornaboda den 31 juli på 1.16,8/2.140 meter och finskfödde <strong>Stoneisle Vertigo</strong> (e. Creatine) vann sin debut fem dagar tidigare i Gävle på 1.17,5/2.140 meter.<br>Den sistnämnde möter en stor talang i Tomas Petterssons <strong>From the Hip</strong> (e. Readly Express) som i sin tur debutvann på vassa 1.15,7/2.140 meter.</p>



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



<p class="has-drop-cap wp-block-paragraph">2 Tvååringar travar ut i det inledande loppet på kvällens huvudbana Örebro (första start kl. 18.20).<br>Såväl Mattias Djuses <strong>Chapter One</strong> (e. Chapter Sveen) som Erlend Rennesviks <strong>Gimmefive Ravin</strong> (e. Ken Warkentin) gjorde tävlingsdebut på Solvalla i förra veckan och då lyckades den förstnämnde bäst med en andraplats medan de övriga fem deltagarna är ostartade.</p>



<p class="wp-block-paragraph">Frida Bergs lördagsföljetång <strong>Benita Winner</strong> (e. Muscle Massive) möter bland annat David Perssons<strong> Georgia Am</strong> (e. Timoko) i ett stolopp.<br>Den sistnämnda skulle ha avslutat sin tävlingskarriär i våras och fått inleda en ny karriär som avelssto, men blev aldrig dräktig utan startar därför igång på nytt.<br>Fredrik B Larssons <strong>Portofino</strong> (e. Charly du Noyer) är en annan häst under tävlingskvällen som vunnit STL-lopp under året medan Daniel Redéns treåring <strong>Epic Kronos</strong> (e. Muscle Hill) som är obesegrad i felfritt lopp nu jagar karriärens fjärde seger i femte försöket.</p>



<p class="wp-block-paragraph">Solänget (första start kl. 18.30) tar rollen som saxbana till Örebro och där sticker ett gäng lördagsbekanta kallblod ut då <strong>Kalmar</strong> (e. Bork Odin) och <strong>Källsjöviking</strong> (e. Järvsöviking) ska försöka hämta in 20 meters tillägg på <strong>Fräcke Prins</strong> (e. Bork Odin) och Norrbo Odin (e. Moe Odin).</p>



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



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



<p class="has-drop-cap wp-block-paragraph">3 Efter att vunnit två lopp på Vincennes under det gångna vintermeetinget följde en tung period för Love You-sonen<strong> In Love d&#8217;Ecajeul</strong>, 1.12,6am/494.644 kr.<br>Nu har den femårige hingsten bytt regi då hästen har lämnat Björn Goops stall och numera finns hos Daniel Wäjersten.<br>Det är Stall Mary AB i Handen som äger hästen och de har nu sex hästar i träning hos Bergsåkerproffset.</p>



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



<p class="has-drop-cap wp-block-paragraph">4Jörgen S Eriksson-tränade<strong> Dollar Doc</strong> (e. Ready Cash) jagar sin andra raka seger på fransk mark vid dagens tävlingar på Enghien (första start kl. 16.08).<br>Efter att vunnit ett montélopp i La Capelle gäller idag tävling för sulky och det sker med Eric Raffin som chaufför i Prix de la Haute-Saone (€52.000) för sex- till nioåriga hästar som högst tjänat 165.000 euro.<br>Vinnaren belönas med 23.400 euro i detta lopp över 2.875 meter voltstart och han sällskapas av Laurent Claude Abrivards svenskfödde<strong> Howdy Quick</strong> (e. Up and Quick).</p>



<figure class="wp-block-image aligncenter size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2020/06/dollardoc-1-617x333.jpg" alt="" class="wp-image-93735"/><figcaption class="wp-element-caption">Dollar Doc ska starta på Enghien. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="wp-block-paragraph">Tomas Malmqvist har i sin tur en tvååringsdebutant i Prix de la Porte de Montreuil (€38.000).<br>Stoet <strong>Lizy Josselyn</strong> (e. Love You) kvalade på 1.17,8 i Caen i början av juli och förväntas utgöra favoritskaran i detta lopp över 2.250 meter voltstart med Eric Raffin som kusk.</p>



<p class="wp-block-paragraph">En som däremot lämnar Parisområdet efter att som bäst slutat sjua på de tre första starterna på huvudstadsbanorna är Stefan Arvidssons <strong>G.K.Justus</strong> (e. Brad de Veluwe).<br>Istället prövar han lyckan i Chateaubriant (första start kl. 11.45) strax efter lunch och denna gång gäller tävling för sadel då sexåringen kommer ut i Prix Meaulnes du Corta (€26.000) tillsammans med Iina Aho som ryttare.<br>Svenskintresse syns även i Prix Ganymede (€20.000) där Jarmo Niskanen startar treårige <strong>Kyoshiro</strong> (e. Charly du Noyer).</p>



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



<p class="has-drop-cap wp-block-paragraph">5Tisdagens tävlingar i Ålborg blev framflyttade till gårdagen på grund av det oväder som rådde i Danmark under tisdagen.<br>I Ålborg avgjordes Travliga-finaler och i snabbloppsklassen var det Flemming Jensens <strong>Emoji</strong> (e. Broad Bahn) som drog längsta strået och förpassade stallkamraten <strong>Empire</strong> (e. Västerbo Prestige) till den tredje raka andraplatsen sedan han gjorde comeback i början av juli.<br>Emoji vann lekande lätt i 1.14,1a/2.140 meter efter att anfört i jämnt tempo hela vägen och höll dödenstravande Empire på behörigt avstånd.<br>Triumfen var värd 50.000 danska kronor och den fjärde för året för Emoji som kördes till vinst av Birger Jörgensen.</p>



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



<p class="has-drop-cap wp-block-paragraph">6Patrik Fernlund fick en drömstart av Amatör-EM i Finland när de två första av totalt fyra lopp avgjordes på Vermo under onsdagkvällen.</p>



<figure class="wp-block-image alignright size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/08/skarmavbild20230809kl.18.01.04-617x372.jpg" alt="" class="wp-image-481526"/><figcaption class="wp-element-caption">Patrik Fernlund jublade efter att vunnit första loppet ingående i Amatör-EM. Foto: Skärmdump ATG Live.</figcaption></figure>



<p class="wp-block-paragraph">Fernlund styrde in favoritspelade <strong>My Match</strong> till seger i första loppet och blev därefter femma bakom <strong>Boom Shaka Laka</strong> i det andra loppet.</p>



<p class="wp-block-paragraph">Idag fortsätter Amatör-SM i Lahti och det är norske Rune Röyrås som leder totaltabellen efter att slutat tvåa i båda onsdagsloppen.</p>



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



<p class="has-drop-cap wp-block-paragraph">7 Inte mindre än tre Grupp-lopp avgörs i italienska Garigliano (första start kl 20.00) under den sena torsdagskvällen.<br>Fyraåringarnas öppna klass av Criterium dei 4 anni (€100.100) har Grupp I-status och är en stjärntät tillställning.<br>Orsi Mangelli-vinnaren <strong>Diamond Francis</strong> (e. Exploit Caf) möter<strong> Desiderio d&#8217;Esi </strong>(e. Robert Bi) som vunnit tre Grupp-lopp bara under detta år och därtill gör fjolårets Derbytvåa<strong> Denzel Treb</strong> (e. Nuncio) debut för sin nya tränare Manuele Matteini.<br>Alessandro Gocciadoros hopp ställs till <strong>Denzel Washington </strong>(e. Victor Gio) som han lånar ut till Giampaolo Minnucci då han själv svingar sig upp bakom <strong>Diamond Truppo</strong> (e. Varenne).</p>



<p class="wp-block-paragraph">De övriga Grupp-loppen Gran Premio Campionato Femmine 3 anni (€66.000) samt Gran Premio Campionato Femmine 4 anni (€66.000) avgörs med Grupp II-status.</p>



<p class="wp-block-paragraph"><strong>Startlista Criterium dei 4 anni</strong><br><em>2.100 meter autostart, förstapris: 35.581 euro</em></p>



<ol class="wp-block-list">
<li>Diluca Mo (e. Lorenz del Ronco) – Marcello di Nicola</li>



<li>Denzel Washington (e. Victor Gio) – Giampaolo Minnucci</li>



<li>Desiderio d&#8217;Esi (e. Robert Bi) – Andrea Farolfi</li>



<li>Daniele Jet (e. Naglo) – Gaetano di Nardo</li>



<li>Diamond Francis (e. Exploit Caf) – Vincenzo P.Dell&#8217;Annunziata</li>



<li>Diamond Truppo (e. Varenne) – Alessandro Gocciadoro</li>



<li>Denzel Treb (e. Nuncio) – Francesco Tufano</li>



<li>Dragowski (e. Algiers Hall) – Antonio di Nardo</li>



<li>Donnavittoria Par (e. Victor Gio) – Vincenzo Luongo</li>
</ol>

Fokustema
Morgonsvepet
Läs senare
Stotopp i lunchlopp
Om en Stochampionatsdeltagare som dyker upp i lunchlopp, Grupp I-lopp i södra Italien samt en svenskfödd häst som jagar ny seger på fransk mark går bland annat att läsa i dagens morgonsvep.
