
<h2 class="wp-block-heading">Kvalificeringslopp 1</h2>



<p class="wp-block-paragraph"><strong>Till final:</strong> <strong>Macahan</strong> (Dwight Pieters) fjärde utvändigt. Med i attack 700 kvar, fram utvändigt ledaren 400 kvar. Tog grepp per omgående och vann säkert, 1.14,2 sista varvet. <strong>Fusion Eagra </strong>(Django Riff) tredje invändigt. Ut i fjärde utvändigt 500 kvar och hakade långt fram i det skedet. Flög fram i vida spår och bärgade andraplatsen med säker marginal.</p>



<p class="wp-block-paragraph"><strong>Noterat i övrigt: Global Embargo</strong> (Per Lennartsson) femte invändigt. Ut i femte utvändigt 900 kvar. Med i attack 700 kvar, framme som andrahäst 400 kvar. Höll den placeringen tills 50 kvar, bra insats. <strong>King Of Twilight</strong> (Stefan Persson) anförde i högt tempo. rundad 500 kvar.<strong> Kojak Sisu</strong> (Mats E Djuse) galopperade långt innan bilen släppte fältet och vägrade ställa sig. <strong>Freako</strong> (Örjan Kihlström) galopperade från start.</p>



<p class="wp-block-paragraph"><strong>Sagt i vinnarcirkeln: </strong>&#8221;<em>Det blev bra körning hela vägen och kändes riktigt bra för min del. Vi trodde att han var redo för det här och när jag tryckte till sista 400 meterna var det bra tag i grejerna. Det här var häftigt; det här är stort för oss och alla i stallet samt ägarna</em>&#8221;, sade Dwight Pieters.</p>



<p class="wp-block-paragraph"><strong>Tempo: </strong>500 m: 1.09,8 (King of Twilight), 1.000 m: 1.13,2 (dito), 2.000 m: 1.14,3 (dito). Sista 500 m: 1.14,6.</p>



<p class="wp-block-paragraph"><strong>Sluttid: </strong>1.14,5a/2.640 meter.</p>



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



<h2 class="wp-block-heading"><strong>Kvalificeringslopp 2</strong></h2>



<p class="wp-block-paragraph"><strong>Till final:</strong> <strong>Boscha Diablo </strong>(Johan Untersteiner) utvändigt ledaren, tog över taktpinnen efter 600 meter och höll ett jämnt, högt tempo hela vägen. Ryckte in mot upploppet och vann på övertygande vis. Topphäst! <strong>Fiftyfour</strong> (Ken Ecce) andra utvändigt. Attackerade 1.050 kvar, utvändigt ledaren 850 kvar. Slagen 150 kvar, men räddade andraplatsen på avstånd. 1.13 sista varvet.</p>



<p class="wp-block-paragraph"><strong>Noterat i övrigt: Caviar From Mine </strong>(Björn Goop) frontade och släppte till vinnaren efter 600 meter. Ut i andra utvändigt 550 kvar, fullföljde starkt utan riktig chans på andra finaplatsen. <strong>Sterbik</strong> (Örjan Kihlström) via tredjespår fram utvändigt ledaren efter 600 meter. Låg på alldeles för friskt. Avlöst 850 kvar, men var slagen kort senare.</p>



<p class="wp-block-paragraph"><strong>Sagt i vinnarcirkeln: </strong>&#8221;<em>Han gjorde faktiskt en sådan här prestation senast i Köpenhamn också. Det märktes redan i Mantorp att han var riktigt på gång. Vi lättade honom i balansen idag och det finns mer växlar kvar att dra av. Han är lite framåt innan loppen och lever på sin styrka så det gäller att hålla honom på mattan; det blir inga ändringar till finalen</em>&#8221;, sade Johan Untersteiner.</p>



<p class="wp-block-paragraph"><strong>Tempo: </strong>500 m: 1.11,0 (Caviar From Mine), 1.000 m: 1.12,2 (Boscha Diablo), 2.000 m: 1.13,9 (dito). Sista 500 m: 1.11,1.</p>



<p class="wp-block-paragraph"><strong>Sluttid: </strong>1.13,2a/2.640 meter.</p>



<figure class="wp-block-image aligncenter size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/10/5boschadiablo-617x333.jpg" alt="" class="wp-image-503415"/><figcaption class="wp-element-caption">Boscha Diablo och Johan Untersteiner vann det andra uttagningsloppet till Svenskt Travkriterium. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



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



<h2 class="wp-block-heading">Kvalificeringslopp 3</h2>



<p class="wp-block-paragraph"><strong>Till final: Nouri di Quattro</strong> (Magnus A Djuse) provade för ledningen efter 500 meter, men backades ner i rygg på ledaren. Gick ut i dödens 1.100 kvar och krigade ner ledaren sista 80 meterna. Fortsatt obesegrad efter fem starter. <strong>Boreas</strong> (Gustav Johansson) tog över täten efter 300 meter. Utmanad om spets, försvarade sin position och höll storstilat.</p>



<p class="wp-block-paragraph"><strong>Noterat i övrigt: Antognoni</strong> (Jorma Kontio) tredje utvändigt. Gick med i rygg på sista bortre långsidan, men utan chans på finalplats. <strong>Epic Kronos</strong> (Örjan Kihlström) utan rygg hela vägen, slagen i sista sväng men höll sin fart på avstånd. Aldrig aktuell. Galopp för <strong>S.G. Dracarys </strong>(Per Lennartsson) kort efter start.</p>



<p class="wp-block-paragraph"><strong>Sagt i vinnarcirkeln:</strong> <em>”Det finns mycket styrka och snabbhet i honom. Idag svarade han bra på rycktussar och det föll väldigt väl ut”</em>, sade Magnus A Djuse.</p>



<p class="wp-block-paragraph"><strong>Tempo:</strong> 500 m: 1.10,4 (Boreas), 1.000 m: 1.13,5 (dito), 2.000 m: 1.14,8 (dito), sista 500 m: 1.12,0.</p>



<p class="wp-block-paragraph"><strong>Sluttid:</strong> 1.14,2a/2.640 meter.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/10/6nouridiquattro-617x333.jpg" alt="" class="wp-image-503420"/><figcaption class="wp-element-caption">Nouri di Quattro och Magnus A Djuse. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



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



<h2 class="wp-block-heading">Kvalificeringslopp 4</h2>



<p class="wp-block-paragraph"><strong>Till final: Fame and Glory</strong> (Björn Goop) utvändigt ledaren hela vägen i tufft tempo. Avgjorde enkelt 150 kvar. Makalös insats och obesegrad efter fem starter. <strong>Frank S.H. </strong>(Thomas Uhrberg) höll ett högt tempo i spets, men fick ge sig till slut. Tapper i nederlaget.</p>



<p class="wp-block-paragraph"><strong>Noterat i övrigt: Savastano</strong> (Adrian Kolgjini) inledde i tredjespår i första kurvan, sedan andra ytter. Kunde inte blanda sig i kampen om en finalplats. <strong>Observe’Em</strong> (Rikard N Skoglund) fjärde ytter, tog sats i tredjespår 500 kvar. Hygglig avslutning på avstånd. <strong>Capricon Trot </strong>(Robert Bergh) ner i rygg ledaren efter 200 meter. Frånåkt i sista sväng.</p>



<p class="wp-block-paragraph"><strong>Sagt i vinnarcirkeln: </strong><em>”Duktig och bra. En ganska allround häst med fin inställning. Det driver väldigt bra för honom och han tog fram det lilla extra som vi hoppades han skulle göra idag”</em>, sade Björn Goop.</p>



<p class="wp-block-paragraph"><strong>Tempo:</strong> 500 m: 1.12,2 (Frank S.H.), 1.000 m: 1.13,9 (dito), 2.000 m: 1.13,9 (dito), sista 500 m: 1.13,2.</p>



<p class="wp-block-paragraph"><strong>Sluttid: </strong>1.13,3a/2.640 meter.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/10/8fameandglory-617x333.jpg" alt="" class="wp-image-503450"/><figcaption class="wp-element-caption">Fame And Glory och Björn Goop. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



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



<h2 class="wp-block-heading"><strong>Kvalificeringslopp 5</strong></h2>



<p class="wp-block-paragraph"><strong>Till final:</strong> <strong>Our Pride</strong> (Magnus A Djuse) utvändigt ledaren, tog över taktpinnen efter 350 meter och kunde sänka farten. Kontrollerade loppet hela vägen och vann tillsynes obrukad. <strong>Kuiper</strong> (Daniel Wäjersten) andra utvändigt. Attackerade in mot upploppet, spurtade starkt och tog andraplatsen med säker marginal utan att hota om segern. 1.11 sista varvet.</p>



<p class="wp-block-paragraph"><strong>Noterat i övrigt: Nelson Greenwood</strong> (Robbin Bot) frontade, släppte efter 350 meter. Hakade på starkt som trea. <strong>Flotilla</strong> (Örjan Kihlström) utvändigt ledaren. Såg stursk ut genom slutkurvan, men var slagen 100 kvar.<strong> Immortal Doc </strong>(Carl Johan Jepson) tredje invändigt. Ut i andraspår 250 kvar och fick fritt kort senare. Sköt till vasst som femma.</p>



<p class="wp-block-paragraph"><strong>Sagt i vinnarcirkeln: </strong>&#8221;En otrolig talang som är häftig att köra. Han kändes ungefär som han gjort innan, men var till och med lite lugnare idag. Det är många bra hästar med i finalen, men visst känns det som en bra chans&#8221;, medgav Magnus A Djuse.</p>



<p class="wp-block-paragraph"><strong>Tempo: </strong>500 m: 1.10,9 (Our Pride), 1.000 m: 1.14,6 (dito), 2.000 m: 1.14,9 (dito). Sista 500 m: 1.10,8.</p>



<p class="wp-block-paragraph"><strong>Sluttid: </strong>1.13,9a/2.640 meter.</p>



<figure class="wp-block-image aligncenter size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/10/11ourpride-617x333.jpg" alt="" class="wp-image-503493"/><figcaption class="wp-element-caption">Our Pride och Magnus A Djuse vann det femte uttagningsloppet till Svenskt Travkriterium. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



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



<h2 class="wp-block-heading"><strong>Kvalificeringslopp 6</strong></h2>



<p class="wp-block-paragraph"><strong>Till final:</strong> <strong>Pantocrator</strong> (Gustav Johansson) tredje utvändigt. Med i attack 650 kvar, fram utvändigt ledaren 500 kvar. Vilade bakom täthästen i slutkurvan innan han satte in ny attack 150 kvar, avgjorde mycket lätt.<strong> Herakles Zet</strong> (Örjan Kihlström) hängde i tredjespår hela första varvet innan han backades ner till sjätte invändigt. Kom fram mellan hästar i slutkurvan och attackerade i vida spår 250 kvar. Flög fram till andraplatsen.</p>



<p class="wp-block-paragraph"><strong>Noterat i övrigt: Stens Rubin</strong> (Johan Untersteiner) andra utvändigt. Attackerade 650 kvar, svepte fältet i ett nafs. Såg mer eller mindre klar ut 300 meter före mål, men mattades markant sista 150 meterna och tappade sin tillsynes klara finalplats. <strong>Global Etalon</strong> (Björn Goop) tog hand om ledningen och höll ett högt tempo. Slagen 500 kvar.</p>



<p class="wp-block-paragraph"><strong>Sagt i vinnarcirkeln: </strong>&#8221;<em>En trevlig häst som varit rullig och galopperat en del, men på senare tid har han utvecklats väldigt mycket. Det gick fort i loppet från början och det blev perfekt för oss. Han vann med mycket krafter sparade</em>&#8221;, sade Gustav Johansson.</p>



<p class="wp-block-paragraph"><strong>Tempo: </strong>500 m: 1.09,3 (Global Etalon), 1.000 m: 1.12,7 (dito), 2.000 m: 1.13,9 (dito). Sista 500 m: 1.xx,x.</p>



<p class="wp-block-paragraph"><strong>Sluttid: </strong>1.13,8a/2.640 meter.</p>



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



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



<p class="wp-block-paragraph"><em>Hästnamn (far) – tränare</em></p>



<ul class="wp-block-list">
<li><strong>Macahan</strong> (e. Maharajah) – Maria Törnqvist</li>



<li><strong>Fusion Eagra</strong> (e. Django Riff) – Eric Martinsson</li>



<li><strong>Boscha Diablo </strong>(e. Traders) – Johan Untersteiner</li>



<li><strong>Fiftyfour </strong>(e. Fourth Dimension) – Tomas Malmqvist</li>



<li><strong>Nouri di Quattro </strong>(e. Southwind Frank) – Timo Nurmos</li>



<li><strong>Boreas </strong>(e. Fourth Dimension) – Dan Widegren (a)</li>



<li><strong>Fame and Glory</strong> (e. Tactical Landing) – Timo Nurmos</li>



<li><strong>Frank S.H.</strong> (e. Fourth Dimension) – Fredrik Persson</li>



<li><strong>Our Pride </strong>(e. Maharajah) – Timo Nurmos</li>



<li><strong>Kuiper</strong> (e. Face Time Bourbon) – Daniel Wäjersten</li>



<li><strong>Pantocrator</strong> (e. Quarcio du Chene) – Jerry Riordan</li>



<li><strong>Herakles Zet </strong>(e. Propulsion) – Daniel Redén</li>
</ul>

Fokustema
Uttagningslopp, Svenskt Travkriterium
Läs senare
Macahan via långspurt
Idag avgörs uttagningsloppen till Svenskt Travkriterium på Solvalla. Här kan du följa hur finalfältet tar form lopp för lopp.
