
<p class="has-drop-cap">1Efter att vunnit fjolårets upplaga av Sundsvall Open Trot med <strong>Moni Viking</strong> (e. Maharajah) är på Björn Goop på ny segerjakt i Bergsåkers största lopp.<br>Bakom Elitloppstvåan <strong>San Moteur </strong>– vars far <strong>Panne de Moteur </strong>vann loppet år 2013 – ska han försöka lösa ett utvändigt spår om Hugo Åbergs Memorial-vinnaren <strong>Hail Mary</strong> (e. Googoo Gaagaa) i strid om en miljon kronor.<br>Den sistnämnde tränas av Daniel Redén som vann loppet år 2015 då <strong>Delicious</strong> (e. Cantab Hall) kutade nya världsrekordet 1.10,0a/2.140 meter, men därefter är Sorbets (e. Super Photo Kosmos) tre raka andraplatser mellan 2018 till 2020 det närmsta han har kommit.<br>I år har Solvallatränaren dubbla chanser då även pånyttfödde <strong>Missle Hill </strong>(e. Muscle Hill) finns med bland de tio deltagarna.</p>



<p>Skulle däremot <strong>Borups Victory</strong> (e. Googoo Gaagaa) lyckas vinna i lag med sin tränare Daniel Wäjersten så blir han den tredje hemmahästen att slå till i Sundsvall Open Trot.<br>År 1998 vann <strong>Zoogin</strong> (e. Zoot Suit) för Åke Svanstedt och år 2014 var Svante Båth Bergsåkerlicenserad när <strong>Quid Pro Quo</strong> (e. Yankee Glide) vann tillsammans med Erik Adielsson.</p>



<h2 class="wp-block-heading">Fem snabbaste upplagorna av Sundsvall Open Trot:</h2>



<ul class="wp-block-list">
<li>2015 – Delicious (e. Cantab Hall) – Örjan Kihlström, 1.10,0</li>



<li>2018 – Milligan&#8217;s School (e. Yankee Glide) – Ulf Eriksson, 1.10,1</li>



<li>2020 – Milligan&#8217;s School (e. Yankee Glide) – Ulf Eriksson, 1.10,6</li>



<li>2013 – Panne de Moteur (e. Credit Winner) – Örjan Kihlström, 1.10,9</li>



<li>2017 – Ringostarr Treb (e. Classic Photo) – Wim Paal, 1.11,1</li>
</ul>



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



<p class="has-drop-cap">2Det är inte bara Sundsvall Open Trot som bjuder på stor sport denna eftermiddag. Svenskt Mästerskap för kallblod avgörs traditionsenligt samma tävlingsdag och det sker med <strong>Månlykke A.M.</strong> (e. Månprinsen A.M.) som förgrundsfigur.<br>Gunnar Melanders häst jagar sin fjärde raka seger i loppet och Melander själv har faktiskt vunnit åtta av de tio senaste upplagorna då Månlykke A.M.:s far Månprinsen A.M. slog till vid fem tillfällen mellan 2013 och 2018.</p>



<p>Lärlingsloppet Lars Lindbergs Minne körs för att hedra en av banans absoluta största tränare och kuskar genom åren vilken gick bort år 2011.<br>Stoloppet lockar med 200.000 kronor i segerpremie och det är lärlingar som svingar sig upp bakom deltagarna, men det har olyckligtvis inte blivit fullbelagt utan innehåller &#8221;bara&#8221; 14 deltagare.<br>Bland dem finns den färska European Championship for Mares-trean <strong>Imhatra Am</strong> (e. Muscle Hill) som körs av William Ekberg för första gången.</p>



<p>På V75 är det jackpot och prognosen säger att sjurättspotten ska innehålla hela 75 miljoner kronor!</p>



<p><em>Vill du spela V75 tillsammans med Sulkysport finns följande alternativ:</em></p>



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



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



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



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



<p class="has-drop-cap">3När Eskilstuna (första start kl. 18.30) står som värd för lördagskvällens tävlingar dyker en sto(r)stjärna upp i det tionde och sista loppet efter V65-spelet har avgjorts.</p>



<p>Det handlar om Fredrik Wallins Sayonara (e. Donato Hanover) som under fjolåret vann Trond Anderssens Minneslopp på Bjerke och slutade tvåa i European Championship for Mares.<br>Den fyrfaldiga miljonärskan har dock inte synts till i tävlingssammanhang sedan hon slutade sexa i Svenskt Mästerskap för ston på Åby den 8 oktober ifjol.<br>– <em>Hon överansträngde sig vid andraplatsen i EM för ston i augusti. Hon gjorde två lopp efter det, men var inte sig lik och fick en paus därefter och chansen att ta igen sig ordentligt</em>, <a href="https://sulkysport.se/comeback-utanfor-rampljuset/" target="_blank" rel="noreferrer noopener">säger Fredrik Wallin.</a></p>



<p>Comeback gör även Jan Raumers <strong>Por Una Cabeza</strong> (e. Zola Boko) som hade ett starkt fjolår med fyra segrar och tre andraplatser på elva starter.<br>I år har sexåringen bara gjort en start vilken utmynnade i galopp på Visbytravet i maj, men nu tar alltså Zola Boko-sonen omtag.</p>



<p><a href="https://sulkysport.se/wp-content/uploads/2023/08/230826.pdf" target="_blank" rel="noreferrer noopener">Här kan du ta del av lördagens startlistor.</a></p>



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



<p class="has-drop-cap">4Idag avgörs Danskt Stoderby när Lunden (första start kl. 12.30) kör sin andra av totalt tre sammanhängande tävlingsdagar.<br>Nio av de tolv deltagarna är anmälda i danska premiechansen vilket innebär att de hästarna belönas med 537.000 danska kronor vid seger medan icke premiechansade hästar får 358.000 dito.</p>



<p>Bo Westergårds <strong>Hallöjsa Vang</strong> (e. S.J.&#8217;s Caviar) har varit klar etta bland stona i kullen såhär långt och jagar nu revansch efter att galopperat bort sig i uttagningsloppet till Jydsk 4-årings GP för ston i juni.<br>I den finalen var det istället stallkamraten <strong>Herina Sotto</strong> (e. Love You) som gick segrande ur striden och hon finns även med i dagens final, om än från ett sjundespår efter att &#8221;bara&#8221; blivit tvåa i sitt uttagningslopp.</p>



<p><strong>Startlista Danskt Stoderby</strong><br><em>2.000 meter autostart</em></p>



<ol class="wp-block-list">
<li>Hallöjsa Vang (e. S.J.&#8217;s Caviar) – Bo Westergård</li>



<li>Helena D D (e. Orlando Vici) – Jeppe Rask</li>



<li>Harper (e. Broadway Hall) – Michael Lönborg</li>



<li>Highfive E M (e. Wishing Stone) – Rene Kjaer (Mikael Poulsen)</li>



<li>Hope Never Dies (e. S.J.&#8217;s Caviar) – Knud Mönster (Ulrik Christoffersen)</li>



<li>Heimaey (e. S.J.&#8217;s Caviar) – Steen Juul</li>



<li>Herina Sotto (e. Love You) – Nicklas Korfitsen (Bo Westergård)</li>



<li>Heti (e. E L Titan) – Ken Ecce</li>



<li>Hashtag Ostendantik (e. Great Challenger) – Birger Jörgensen (Steen Juul)</li>



<li>Hovita (e. Infinitif) – Kasper K Andersen (Jeppe Rask)</li>



<li>Hollywood (e. Great Challenger) – Jeppe Juel</li>



<li>Hej Bork (e. Great Challenger) – Casper M Nielsen (Kaj Jensen)</li>
</ol>



<p>På Lunden körs även ett öppet stolopp namngivet Tella the Greats lopp med 75.000 danska kronor i segerpremie och där finns fyra svensktränade hästar med i startlistan.<br>Tomas Malmqvist luftar<strong> Nannys Girl </strong>(e. S.J.&#8217;s Caviar), Conrad Lugauer bidrar med <strong>Devs Daffodil </strong>(e. Enjoy Lavec), Fredrik Persson med <strong>Deborah S.H.</strong> (e. Maharajah) som får Stefan Persson som kusk och så har det relativt färska Jägersroproffset Gennaro Casillo med <strong>Collier I.T.</strong> (e. Maharajah).</p>



<p><a href="https://travbanen.dk/media/8482052/Lunden_26-08-23_N-1-.pdf" target="_blank" rel="noreferrer noopener">Här kan du ta del av dagens banprogram till tävlingarna på Lunden.</a></p>



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



<p class="has-drop-cap">5På Vincennes (första start kl. 14.15) står det stora pengar på spel i Yearling Cup 2023 – Arqana Trot (€150.000).<br>Treåringsloppet är enbart öppet för hästar som såldes på auktion i Deauville mellan 1-3 september år 2021 och bland de 15 deltagarna i dagens lopp syns tre hästar från Tomas Malmqvists stall.</p>



<p>Ready Cash-sonen <strong>Kapitano de Source</strong> som inlett karriären med fem segrar på sju starter och körs av Eric Raffin ser ut att vara den hetaste av dem, men inte heller hans andra kort<strong> Kash Madrik </strong>(e. Ready Cash) eller<strong> Kacha de Vandel </strong>(e. Pacha du Pont) bedöms vara utan chans i jakten på segerchecken på 67.500 euro.</p>



<p>I Grupp III-klassade Prix de Provence (€90.000) för fem- till sjuåriga hästar som högst tjänat 375.000 euro kommer fjolårets Harper Hanovers lopp-tvåa <strong>Selected News</strong> (e. Maharajah) till start.<br>Thierry Duvaldestins svenskfödda sexåring körs av Clément Duvaldestin och blågult intresse finns även i treåringsloppet Prix Phact (€80.000) för inhemska sadelhästar där Tomas Malmqvist startar <strong>Kobalt du Vallon</strong> (e. Quaker Jet).</p>



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



<p class="has-drop-cap">6I italienska Follonica (första start kl. 20.25) avgörs idag Gran Premio Citta&#8217; di Folloncia (€66.000) för såväl fyraåriga hingstar och valacker som ston.</p>



<p>I Alessandro Gocciadoros frånvaro får Francesco Tufano chansen bakom kullettan <strong>Daughter As </strong>(e. Father Patrick) i stoklassen medan Antonio Simioli svingar sig upp bakom hans starkaste hingstkort <strong>Diamond Truppo </strong>(e. Varenne).<br>I den sistnämnda klassen startar därtill Destino DJ (e. Wishing Stone) som ägs av Horse Breeding in Sweden och som numera finns hos Erik Bondo efter att tidigare tränats av Timo Nurmos.</p>



<p><strong>Startlista Gran Premio Citta&#8217; di Folloncia &#8211; h/v</strong><br><em>2.200 meter autostart, förstapris: 23.460 euro</em></p>



<ol class="wp-block-list">
<li>Destino DJ (e. Wishing Stone) – Federico Esposito</li>



<li>Diamond Truppo (e. Varenne) – Antonio Simioli</li>



<li>Dolce Viky (e. Adrian Chip) – Manuel Pistone</li>



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



<li>Day of Glory (e. Exploit Caf) – Edoardo Baldi</li>



<li>Dakar (e. Varenne) – Antonio di Nardo</li>



<li>Don King Muttley (e. Tobin Kronos) – Enrico Bellei</li>



<li>Danielino (e. Oreste) – Francesco Facci</li>



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



<li>Don Gio Nobel (e. Owen Cr) – Crescenzo Maione</li>



<li>Daino Toscano Key (e. Napoleon Bar) – Antonio Greppi</li>



<li>Dimitri Ferm (e. Nad Al Sheba) – Andrea Farolfi</li>
</ol>



<p><strong>Startlista Gran Premio Citta&#8217; di Folloncia &#8211; ston</strong><br><em>2.200 meter autostart, förstapris: 23.460 euro</em></p>



<ol class="wp-block-list">
<li>Due Italia (e. Adrian Chip) – Andrea Farolfi</li>



<li>Diana Pizz (e. No Reply) – Manuel Pistone</li>



<li>Daytona Roc (e. Filipp Roc) – Filippo Rocca</li>



<li>Dolcezza Sergio (e. Chapeau) – Marco Stefani</li>



<li>Dalila Bar (e. Robert Bi) – Edoardo Loccisano</li>



<li>Diva Ek (e. Trixton) – Santo Mollo</li>



<li>Dali Prav (e. Donato Hanover) – Rene&#8217; Legati</li>



<li>Dilva Jet (e. Maharajah) – Ferdinando Pisacane</li>



<li>Daughter As (e. Father Patrick) – Francesco Tufano</li>



<li>Duna di Girifalco (e. Donato Hanover) – Antonio di Nardo</li>



<li>Dada del Ronco (e. Lorenz Del Ronco) – Marcello Vecchione</li>



<li>Donnavittoria Par (e. Victor Gio) – Gaetano di Nardo</li>



<li>Doni Maker (e. Yankee Slide) – Antonio Simioli</li>
</ol>



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



<p class="has-drop-cap">7Det är inte bara på Vincennes som det tävlas om stora prispengar på fransk mark denna lördag.<br>I Cagnes-sur-Mer (första start kl. 18.45) avgörs traditionsenligt Grand Prix du Departement des Alpes-Mari (€180.000) den sista lördagen i augusti för den äldre eliten.</p>



<p>Loppet innehåller ingen svenskfödd eller svensktränad häst, men däremot flera hästar som presterat väl på svensk mark.<br>Elitloppstvåan <strong>Go On Boy </strong>(e. Password) finns bland deltagarna liksom fjolårets vinnare av Lady Snärts lopp samt Sweden Cup; <strong>Heliade du Goutier</strong> (e. Prodigious) och<strong> Bepi Bi </strong>(e. Donato Hanover).</p>



<p><strong>Startlista Grand Prix du Departement des Alpes-Mari</strong><br><em>1.609 meter autostart, förstapris: 81.000 euro</em></p>



<ol class="wp-block-list">
<li><strong>Go On Boy</strong> – Romain Derieux</li>



<li><strong>Heliade du Goutier</strong> – Nicolas Ensch</li>



<li><strong>Capital Mail </strong>– Gabriele Gelormini</li>



<li><strong>Bepi Bi </strong>– Andrea Guzzinati</li>



<li><strong>Eclat de Gloire</strong> – Loris Garcia</li>



<li><strong>Bleff Dipa</strong> – Roberto Vecchione</li>



<li><strong>Ecureuil Jenilou</strong> – Gwenn Junod</li>



<li><strong>El Greco Bello</strong> – Jean-Charles Feron</li>



<li><strong>Always Ek</strong> – Massimo Castaldo</li>



<li><strong>Eberton</strong> – Junior Guelpa</li>



<li><strong>Chance Ek</strong> – Pietro Gubellini</li>
</ol>



<p>Ytterligare två franska banor tävlar denna lördag, men då utan premiumstatus. I Saint-Galmier (första start kl. 16.30) startar Emilia Gettermann <strong>Madame af Djupmyra</strong> (e. Formula One) och Didier Brohier <strong>Mellby Guard</strong> (e. Going Kronos) i Prix Saint Etienne La Metropole-Race and Care (€22.000).</p>



<p>I Avranches (första start kl. 14.00) jagar Markus B Svedbergs <strong>Kimi di Quattro</strong> (e. Maharajah) sin tredje seger på gräsbana i Prix des Vans M.T.M. (€21.000) och han gör det i strid mot den svenskfödda duon <strong>Happy Few </strong>(e. Ready Cash) och <strong>Staro Mojito</strong> (e. Make It Happen).</p>
